Tworzenie i konfigurowanie wszystkich zasobów dla wnioskowania modelu AI platformy Azure

Artykuł
01/30/2025

Ważne

Elementy oznaczone (wersja zapoznawcza) w tym artykule są obecnie dostępne w publicznej wersji zapoznawczej. Ta wersja zapoznawcza jest udostępniana bez umowy dotyczącej poziomu usług i nie zalecamy korzystania z niej w przypadku obciążeń produkcyjnych. Niektóre funkcje mogą być nieobsługiwane lub ograniczone. Aby uzyskać więcej informacji, zobacz Uzupełniające warunki korzystania z wersji zapoznawczych platformy Microsoft Azure.

Z tego artykułu dowiesz się, jak utworzyć zasoby wymagane do korzystania z wnioskowania modelu sztucznej inteligencji platformy Azure i korzystać z flagowych modeli z katalogu modeli sztucznej inteligencji platformy Azure.

Wymagania wstępne

Aby ukończyć pracę z tym artykułem, potrzebne są następujące zasoby:

Subskrypcja Azure. Jeśli używasz modeli GitHub, możesz uaktualnić środowisko i utworzyć subskrypcję platformy Azure w tym procesie. Przeczytaj artykuł Upgrade from GitHub Models to Azure AI model inference if's your case (Uaktualnianie modeli Usługi GitHub do wnioskowania modelu AI platformy Azure), jeśli tak jest.

Ważne

Portal usługi Azure AI Foundry używa projektów i centrów do tworzenia kont usług Azure AI Services i konfigurowania wnioskowania modelu AI platformy Azure. Jeśli nie chcesz używać centrów i projektów, możesz utworzyć zasoby przy użyciu interfejsu wiersza polecenia platformy Azure, Bicep lub utworzyć zasób usług Azure AI przy użyciu witryny Azure Portal.

Tworzenie zasobów

Aby utworzyć projekt przy użyciu konta usług Azure AI Services, wykonaj następujące kroki:

Przejdź do portalu usługi Azure AI Foundry.
Na stronie docelowej wybierz pozycję Utwórz projekt.
Nadaj projektowi nazwę, na przykład "my-project".
W tym samouczku utworzymy nowy projekt w nowym centrum sztucznej inteligencji, dlatego wybierzemy pozycję Utwórz nowe centrum.
Nadaj koncentratorowi nazwę, na przykład "my-hub", a następnie wybierz pozycję Dalej.
Kreator aktualizuje szczegółowe informacje o zasobach, które mają zostać utworzone. Wybierz pozycję Zasoby platformy Azure do utworzenia , aby wyświetlić szczegóły.

Zobaczysz, że tworzone są następujące zasoby:

Właściwości	opis
Grupa zasobów	Główny kontener dla wszystkich zasobów na platformie Azure. Ułatwia to organizowanie zasobów, które współpracują ze sobą. Pomaga również mieć zakres kosztów związanych z całym projektem.
Lokalizacja	Region tworzonych zasobów.
Piasta	Główny kontener dla projektów sztucznej inteligencji w narzędziu Azure AI Foundry. Centra promują współpracę i umożliwiają przechowywanie informacji dotyczących projektów.
Usługi sztucznej inteligencji	Zasób umożliwiający dostęp do flagowych modeli w katalogu modeli usługi Azure AI. W tym samouczku zostanie utworzone nowe konto, ale zasoby usług Azure AI mogą być współużytkowane w wielu centrach i projektach. Koncentratory używają połączenia z zasobem, aby mieć dostęp do dostępnych tam wdrożeń modelu. Aby dowiedzieć się, jak tworzyć połączenia między projektami i usługami Azure AI w celu korzystania z wnioskowania modelu AI platformy Azure, możesz przeczytać artykuł Connect your AI project (Łączenie projektu sztucznej inteligencji).

Wybierz pozycję Utwórz. Rozpoczyna się proces tworzenia zasobów.
Po zakończeniu projekt jest gotowy do skonfigurowania.
Wnioskowanie modelu AI platformy Azure to funkcja w wersji zapoznawczej, która musi być włączona w rozwiązaniu Azure AI Foundry. Na górnym pasku nawigacyjnym w prawym rogu wybierz ikonę Funkcje w wersji zapoznawczej. Po prawej stronie ekranu zostanie wyświetlony blok kontekstowy.
Włącz funkcję Wdrażanie modeli w usłudze wnioskowania modelu sztucznej inteligencji platformy Azure.
Zamknij panel.
Aby korzystać z wnioskowania modelu AI platformy Azure, należy dodać wdrożenia modelu do konta usług Azure AI.

Dodawanie i konfigurowanie modeli

Ważne

Możesz zdecydować i skonfigurować, które modele są dostępne do wnioskowania w punkcie końcowym wnioskowania. Po skonfigurowaniu danego modelu można wygenerować z niego przewidywania, wskazując jego nazwę modelu lub nazwę wdrożenia na żądaniach. Do użycia w kodzie nie są wymagane żadne dalsze zmiany.

W tym artykule dowiesz się, jak dodać nowy model do wnioskowania modelu AI platformy Azure w usłudze Azure AI Foundry.

Wymagania wstępne

Aby ukończyć pracę z tym artykułem, potrzebne są następujące zasoby:

Subskrypcja Azure. Jeśli używasz modeli GitHub, możesz uaktualnić środowisko i utworzyć subskrypcję platformy Azure w tym procesie. Przeczytaj artykuł Upgrade from GitHub Models to Azure AI model inference if's your case (Uaktualnianie modeli Usługi GitHub do wnioskowania modelu AI platformy Azure), jeśli tak jest.
Zasób usług AI platformy Azure.

Zainstaluj interfejs wiersza polecenia platformy Azure i cognitiveservices rozszerzenie dla usług Azure AI:
```
az extension add -n cognitiveservices
```
Niektóre polecenia w tym samouczku używają jq narzędzia, które może nie być zainstalowane w systemie. Aby uzyskać instrukcje dotyczące instalacji, zobacz Pobieranie jqpliku .
Zidentyfikuj następujące informacje:
- Identyfikator subskrypcji platformy Azure.
- Nazwa zasobu usług Azure AI Services.
- Grupa zasobów, w której wdrożono zasób usług Azure AI Services.

Dodawanie modeli

Aby dodać model, należy najpierw zidentyfikować model, który chcesz wdrożyć. Dostępne modele można wykonywać w następujący sposób:

Zaloguj się do subskrypcji platformy Azure:
```
az login
```
Jeśli masz więcej niż 1 subskrypcję, wybierz subskrypcję, w której znajduje się zasób:
```
az account set --subscription $subscriptionId>
```
Ustaw następujące zmienne środowiskowe z nazwą zasobu usług Azure AI Services, którego chcesz użyć, i grupę zasobów.
```
accountName="<ai-services-resource-name>"
resourceGroupName="<resource-group>"
```
Jeśli nie masz jeszcze utworzonego konta usług Azure AI Services, możesz go utworzyć w następujący sposób:
```
az cognitiveservices account create -n $accountName -g $resourceGroupName
```

Najpierw zobaczmy, które modele są dostępne dla Ciebie i w ramach której jednostki SKU. Poniższe polecenie wyświetli listę wszystkich dostępnych definicji modelu:

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

Dane wyjściowe wyglądają następująco:

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

Zidentyfikuj model, który chcesz wdrożyć. Potrzebne są właściwości name, , formatversioni sku. Pojemność może być również potrzebna w zależności od typu wdrożenia.

Napiwek

Zwróć uwagę, że nie wszystkie modele są dostępne we wszystkich jednostkach SKU.

Dodaj wdrożenie modelu do zasobu. W poniższym przykładzie dodano polecenie 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

Model jest gotowy do użycia.

Ten sam model można wdrożyć wiele razy, jeśli jest to konieczne, o ile ma inną nazwę wdrożenia. Ta funkcja może być przydatna w przypadku, gdy chcesz przetestować różne konfiguracje dla danego modelu, w tym bezpieczeństwo zawartości.

Zarządzanie wdrożeniami

Wszystkie wdrożenia są dostępne przy użyciu interfejsu wiersza polecenia:

Uruchom następujące polecenie, aby wyświetlić wszystkie aktywne wdrożenia:

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

Szczegółowe informacje o danym wdrożeniu można zobaczyć:

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

Możesz usunąć dane wdrożenie w następujący sposób:

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

Korzystanie z modelu

Wdrożone modele w wnioskowaniu modelu AI platformy Azure można używać przy użyciu punktu końcowego wnioskowania modelu AI platformy Azure dla zasobu. Podczas konstruowania żądania wskaż parametr model i wstaw utworzoną nazwę wdrożenia modelu. Identyfikator URI punktu końcowego wnioskowania można uzyskać programowo przy użyciu następującego kodu:

Punkt końcowy wnioskowania

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

Aby wysyłać żądania do punktu końcowego wnioskowania modelu AI platformy Azure, dołącz trasę models, na przykład https://<resource>.services.ai.azure.com/models. Dokumentacja interfejsu API dla punktu końcowego jest widoczna na stronie dokumentacji interfejsu API wnioskowania modelu AI platformy Azure.

Klucze wnioskowania

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

Ważne

Wymagania wstępne

Aby ukończyć pracę z tym artykułem, potrzebne są następujące zasoby:

Subskrypcja Azure. Jeśli używasz modeli GitHub, możesz uaktualnić środowisko i utworzyć subskrypcję platformy Azure w tym procesie. Przeczytaj artykuł Upgrade from GitHub Models to Azure AI model inference if's your case (Uaktualnianie modeli Usługi GitHub do wnioskowania modelu AI platformy Azure), jeśli tak jest.

Zainstaluj interfejs wiersza polecenia platformy Azure.
Zidentyfikuj następujące informacje:
- Identyfikator subskrypcji platformy Azure.

Informacje o tym samouczku

Przykład w tym artykule jest oparty na przykładach kodu zawartych w repozytorium Azure-Samples/azureai-model-inference-bicep . Aby uruchomić polecenia lokalnie bez konieczności kopiowania lub wklejania zawartości pliku, użyj następujących poleceń, aby sklonować repozytorium i przejść do folderu dla języka kodowania:

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

Pliki dla tego przykładu znajdują się w następujących elementach:

cd azureai-model-inference-bicep/infra

Omówienie zasobów

Samouczek ułatwia tworzenie następujących zadań:

Zasób usług Azure AI Services.
Wdrożenie modelu w standardowej jednostce SKU globalnej dla każdego z modeli obsługujących płatność zgodnie z rzeczywistym użyciem.
(Opcjonalnie) Projekt i centrum sztucznej inteligencji platformy Azure.
(Opcjonalnie) Połączenie między piastą a modelami w usługach Azure AI Services.

Do utworzenia tych zasobów są używane następujące zasoby:

Użyj szablonu modules/ai-services-template.bicep , aby opisać zasób usług 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: {
    publicNetworkAccess: publicNetworkAccess
    networkAcls: {
      defaultAction: networkAclsDefaultAction
    }
    disableLocalAuth: allowKeys
  }
}

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

Użyj szablonu modules/ai-services-deployment-template.bicep , aby opisać wdrożenia modelu:

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

Dla wygody definiujemy model, który chcemy udostępnić w usłudze przy użyciu pliku JSON. Plik infra/models.json zawiera listę obiektów JSON z kluczami name,versionprovider i sku, który definiuje modele, które będą aprowizować wdrożenie. Ponieważ modele obsługują płatność zgodnie z rzeczywistym użyciem, dodawanie wdrożeń modeli nie wiąże się z dodatkowymi kosztami. Zmodyfikuj plik usuwający/dodając wpisy modelu, które mają być dostępne. Poniższy przykład przedstawia tylko pierwsze 7 wierszy pliku JSON:

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

Jeśli planujesz używać projektów (zalecane), potrzebne są szablony do tworzenia projektu, centrum i połączenia z zasobem usługi 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
    }
  }
}

Tworzenie zasobów

W konsoli wykonaj następujące kroki:

Zdefiniuj główne wdrożenie:

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

Zaloguj się do platformy Azure:
```
az login
```
Upewnij się, że jesteś w odpowiedniej subskrypcji:
```
az account set --subscription "<subscription-id>"
```

Uruchom wdrożenie:

RESOURCE_GROUP="<resource-group-name>"

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

Jeśli chcesz wdrożyć tylko zasób usług Azure AI i wdrożenia modelu, użyj następującego pliku wdrożenia:

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

Uruchom wdrożenie:

RESOURCE_GROUP="<resource-group-name>"

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

Szablon generuje punkt końcowy wnioskowania modelu AI platformy Azure, którego można użyć do korzystania z dowolnych utworzonych wdrożeń modelu.

Następne kroki

Tworzenie aplikacji przy użyciu usługi wnioskowania modelu AI platformy Azure w usługach azure AI

Udostępnij za pośrednictwem

Tworzenie i konfigurowanie wszystkich zasobów dla wnioskowania modelu AI platformy Azure

Wymagania wstępne

Tworzenie zasobów

Wymagania wstępne

Dodawanie modeli

Zarządzanie wdrożeniami

Korzystanie z modelu

Wymagania wstępne

Informacje o tym samouczku

Omówienie zasobów

Tworzenie zasobów

Następne kroki

Opinia

Dodatkowe zasoby