Alle resources voor azure AI-modeldeductie maken en configureren

Artikel
01/30/2025

Belangrijk

Items die in dit artikel zijn gemarkeerd (preview) zijn momenteel beschikbaar als openbare preview. Deze preview wordt aangeboden zonder een service level agreement en we raden deze niet aan voor productieworkloads. Misschien worden bepaalde functies niet ondersteund of zijn de mogelijkheden ervan beperkt. Zie Aanvullende gebruiksvoorwaarden voor Microsoft Azure-previews voor meer informatie.

In dit artikel leert u hoe u de resources maakt die nodig zijn voor het gebruik van azure AI-modeldeductie en het verbruiken van vlaggenschipmodellen uit de Azure AI-modelcatalogus.

Vereisten

U hebt het volgende nodig om dit artikel te voltooien:

Een Azure-abonnement. Als u GitHub-modellen gebruikt, kunt u uw ervaring upgraden en een Azure-abonnement maken in het proces. Lees Upgrade van GitHub-modellen naar Azure AI-modeldeductie als dat uw geval is.

Belangrijk

Azure AI Foundry Portal maakt gebruik van projecten en hubs om Azure AI Services-accounts te maken en deductie van Azure AI-modellen te configureren. Als u geen hubs en projecten wilt gebruiken, kunt u de resources maken met behulp van de Azure CLI, Bicep of de Azure AI-servicesresource maken met behulp van Azure Portal.

De resources maken

Volg deze stappen om een project te maken met een Azure AI Services-account:

Ga naar de Azure AI Foundry-portal.
Selecteer Project maken op de landingspagina.
Geef het project een naam, bijvoorbeeld 'my-project'.
In deze zelfstudie maken we een gloednieuw project onder een nieuwe AI-hub. Selecteer daarom Nieuwe hub maken.
Geef de hub een naam, bijvoorbeeld 'my-hub' en selecteer Volgende.
De wizard wordt bijgewerkt met details over de resources die worden gemaakt. Selecteer Azure-resources die moeten worden gemaakt om de details te bekijken.

U kunt zien dat de volgende resources zijn gemaakt:

Eigenschappen	Beschrijving
Resourcegroep	De hoofdcontainer voor alle resources in Azure. Dit helpt bij het ophalen van resources die samenwerken. Het helpt ook om een bereik te hebben voor de kosten die aan het hele project zijn gekoppeld.
Locatie	De regio van de resources die u maakt.
Hub	De belangrijkste container voor AI-projecten in Azure AI Foundry. Hubs bevorderen samenwerking en bieden u de mogelijkheid om informatie voor uw projecten op te slaan.
AI-services	De resource die toegang biedt tot de vlaggenschipmodellen in de Azure AI-modelcatalogus. In deze zelfstudie wordt een nieuw account gemaakt, maar Azure AI-servicesbronnen kunnen worden gedeeld in meerdere hubs en projecten. Hubs gebruiken een verbinding met de resource om toegang te hebben tot de modelimplementaties die daar beschikbaar zijn. Als u wilt weten hoe u verbindingen kunt maken tussen projecten en Azure AI Services om deductie van Azure AI-modellen te gebruiken, kunt u Uw AI-project verbinden lezen.

Selecteer Maken. Het proces voor het maken van resources wordt gestart.
Zodra het project is voltooid, is het klaar om te worden geconfigureerd.
Azure AI-modeldeductie is een preview-functie die moet worden ingeschakeld in Azure AI Foundry. Selecteer in de bovenste navigatiebalk, rechtsboven, het pictogram Voorbeeldfuncties . Rechts van het scherm wordt een contextuele blade weergegeven.
Schakel de functie Modellen implementeren in azure AI-modeldeductieservice in.
Sluit het paneel.
Als u azure AI-modeldeductie wilt gebruiken, moet u modelimplementaties toevoegen aan uw Azure AI-services-account.

Modellen toevoegen en configureren

Belangrijk

U kunt bepalen en configureren welke modellen beschikbaar zijn voor deductie in het deductie-eindpunt. Wanneer een bepaald model is geconfigureerd, kunt u er vervolgens voorspellingen van genereren door de modelnaam of implementatienaam voor uw aanvragen aan te geven. Er zijn geen verdere wijzigingen vereist in uw code om deze te gebruiken.

In dit artikel leert u hoe u een nieuw model toevoegt aan Azure AI-modeldeductie in Azure AI Foundry.

Vereisten

U hebt het volgende nodig om dit artikel te voltooien:

Een Azure-abonnement. Als u GitHub-modellen gebruikt, kunt u uw ervaring upgraden en een Azure-abonnement maken in het proces. Lees Upgrade van GitHub-modellen naar Azure AI-modeldeductie als dat uw geval is.
Een Azure AI-servicesresource.

Installeer de Azure CLI en de cognitiveservices extensie voor Azure AI Services:
```
az extension add -n cognitiveservices
```
Sommige opdrachten in deze zelfstudie gebruiken het jq hulpprogramma, dat mogelijk niet in uw systeem is geïnstalleerd. Zie Downloaden jqvoor installatie-instructies.
Identificeer de volgende informatie:
- Uw Azure-abonnements-id.
- De resourcenaam van uw Azure AI Services.
- De resourcegroep waarin de Azure AI Services-resource wordt geïmplementeerd.

Modellen toevoegen

Als u een model wilt toevoegen, moet u eerst het model identificeren dat u wilt implementeren. U kunt als volgt een query uitvoeren op de beschikbare modellen:

Meld u aan bij uw Azure-abonnement:
```
az login
```
Als u meer dan 1 abonnement hebt, selecteert u het abonnement waarin uw resource zich bevindt:
```
az account set --subscription $subscriptionId>
```
Stel de volgende omgevingsvariabelen in met de naam van de Azure AI Services-resource die u wilt gebruiken en resourcegroep.
```
accountName="<ai-services-resource-name>"
resourceGroupName="<resource-group>"
```
Als u nog geen Azure AI Services-account hebt gemaakt, kunt u er als volgt een maken:
```
az cognitiveservices account create -n $accountName -g $resourceGroupName
```

Laten we eerst kijken welke modellen beschikbaar zijn voor u en onder welke SKU. Met de volgende opdracht worden alle beschikbare modeldefinities weergegeven:

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

Uitvoer ziet er als volgt uit:

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

Identificeer het model dat u wilt implementeren. U hebt de eigenschappenname, format, en versionsku. Capaciteit kan ook nodig zijn, afhankelijk van het type implementatie.

Tip

U ziet dat niet alle modellen beschikbaar zijn in alle SKU's.

Voeg de modelimplementatie toe aan de resource. In het volgende voorbeeld wordt het volgende toegevoegd 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

Het model is klaar om te worden gebruikt.

U kunt hetzelfde model meerdere keren implementeren als dat nodig is zolang het zich onder een andere implementatienaam bevindt. Deze mogelijkheid kan nuttig zijn voor het geval u verschillende configuraties voor een bepaald model wilt testen, inclusief de veiligheid van inhoud.

Implementaties beheren

U kunt alle beschikbare implementaties bekijken met behulp van de CLI:

Voer de volgende opdracht uit om alle actieve implementaties weer te geven:

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

U kunt de details van een bepaalde implementatie bekijken:

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

U kunt een bepaalde implementatie als volgt verwijderen:

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

Het model gebruiken

Geïmplementeerde modellen in Azure AI-modeldeductie kunnen worden gebruikt met behulp van het deductie-eindpunt van het Azure AI-model voor de resource. Wanneer u uw aanvraag maakt, geeft u de parameter model aan en voegt u de naam van de modelimplementatie in die u hebt gemaakt. U kunt de URI voor het deductie-eindpunt programmatisch ophalen met behulp van de volgende code:

Deductie-eindpunt

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

Als u aanvragen wilt indienen bij het deductie-eindpunt van het Azure AI-model, voegt u bijvoorbeeld https://<resource>.services.ai.azure.com/modelsde route modelstoe. U kunt de API-verwijzing voor het eindpunt bekijken op de referentiepagina van de Deductie-API voor Azure AI-modellen.

Deductiesleutels

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

Belangrijk

In dit artikel leert u hoe u de resources maakt die nodig zijn voor het gebruik van azure AI-modeldeductie en het verbruiken van vlaggenschipmodellen uit de Azure AI-modelcatalogus.

Vereisten

U hebt het volgende nodig om dit artikel te voltooien:

Een Azure-abonnement. Als u GitHub-modellen gebruikt, kunt u uw ervaring upgraden en een Azure-abonnement maken in het proces. Lees Upgrade van GitHub-modellen naar Azure AI-modeldeductie als dat uw geval is.

Installeer de Azure CLI.
Identificeer de volgende informatie:
- Uw Azure-abonnements-id.

Over deze zelfstudie

Het voorbeeld in dit artikel is gebaseerd op codevoorbeelden in de opslagplaats Azure-Samples/azureai-model-inference-bicep . Als u de opdrachten lokaal wilt uitvoeren zonder bestandsinhoud te hoeven kopiëren of plakken, gebruikt u de volgende opdrachten om de opslagplaats te klonen en naar de map voor uw programmeertaal te gaan:

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

De bestanden voor dit voorbeeld bevinden zich in:

cd azureai-model-inference-bicep/infra

Informatie over de resources

De zelfstudie helpt u bij het maken van:

Een Azure AI Services-resource.
Een modelimplementatie in de algemene standaard-SKU voor elk van de modellen die betalen per gebruik ondersteunen.
(Optioneel) Een Azure AI-project en -hub.
(Optioneel) Een verbinding tussen de hub en de modellen in Azure AI Services.

U gebruikt de volgende assets om deze resources te maken:

Gebruik de sjabloon modules/ai-services-template.bicep om uw Azure AI Services-resource te beschrijven:

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

Gebruik de sjabloon modules/ai-services-deployment-template.bicep om modelimplementaties te beschrijven:

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

Voor het gemak definiëren we het model dat we in de service beschikbaar willen hebben met behulp van een JSON-bestand. Het bestand infra/models.json bevat een lijst met JSON-objecten met sleutelsname,versionprovider ensku, waarmee de modellen worden gedefinieerd die door de implementatie worden ingericht. Omdat de modellen betalen per gebruik ondersteunen, worden er geen extra kosten in rekening gebracht bij het toevoegen van modelimplementaties. Wijzig het bestand dat de modelvermeldingen verwijdert of toevoegt die u beschikbaar wilt hebben. In het volgende voorbeeld ziet u alleen de eerste 7 regels van het JSON-bestand:

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

Als u projecten wilt gebruiken (aanbevolen), hebt u de sjablonen nodig voor het maken van een project, hub en een verbinding met de Azure AI Services-resource:

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

De resources maken

Voer in uw console de volgende stappen uit:

Definieer de hoofdimplementatie:

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

Meld u aan bij Azure:
```
az login
```
Zorg ervoor dat u zich in het juiste abonnement bevindt:
```
az account set --subscription "<subscription-id>"
```

Voer de implementatie uit:

RESOURCE_GROUP="<resource-group-name>"

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

Als u alleen de Azure AI Services-resource en de modelimplementaties wilt implementeren, gebruikt u het volgende implementatiebestand:

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

Voer de implementatie uit:

RESOURCE_GROUP="<resource-group-name>"

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

Met de sjabloon wordt het eindpunt voor deductie van het Azure AI-model uitgevoerd dat u kunt gebruiken om alle modelimplementaties te gebruiken die u hebt gemaakt.

Volgende stappen

Toepassingen ontwikkelen met behulp van azure AI-modeldeductieservice in Azure AI-services

Delen via

Alle resources voor azure AI-modeldeductie maken en configureren

Vereisten

De resources maken

Vereisten

Modellen toevoegen

Implementaties beheren

Het model gebruiken

Vereisten

Over deze zelfstudie

Informatie over de resources

De resources maken

Volgende stappen

Feedback

Aanvullende resources