Erstellen und Konfigurieren aller Ressourcen für Microsoft Foundry Models

Wichtig

In diesem Artikel markierte Elemente (Vorschau) befinden sich derzeit in der öffentlichen Vorschau. Diese Vorschau wird ohne Vereinbarung auf Serviceebene bereitgestellt und wird für Produktionsworkloads nicht empfohlen. Bestimmte Features werden möglicherweise nicht unterstützt oder weisen eingeschränkte Funktionen auf. Weitere Informationen finden Sie unter Supplementale Nutzungsbedingungen für Microsoft Azure Previews.

In diesem Artikel erfahren Sie, wie Sie die ressourcen erstellen, die zum Verwenden Microsoft Foundry Models in Ihren Projekten erforderlich sind.

Grundlegendes zu den Ressourcen

Foundry Models ist eine Funktion in Foundry Services (früher bekannt Azure AI Services). Unter der Ressource können Sie Bereitstellungen von Modellen erstellen, um deren Vorhersagen zu verwenden. Sie können die Ressource auch mit Azure AI Hubs und Projects in Foundry verbinden, um bei Bedarf intelligente Anwendungen zu erstellen. Die folgende Abbildung zeigt die allgemeine Architektur.

Foundry Services erfordert keine KI-Projekte oder KI-Hubs, um zu arbeiten, und Sie können sie erstellen, um Flaggschiffmodelle aus Ihren Anwendungen zu nutzen. Weitere Funktionen sind jedoch verfügbar, wenn Sie ein Foundry-Projekt und einen Hub bereitstellen, einschließlich Playground oder Agents.

Das Lernprogramm hilft Ihnen beim Erstellen von:

Eine Foundry-Ressource.
Eine Modellbereitstellung für jedes der Modelle, die mit serverlosen API-Bereitstellungen unterstützt werden.
(Optional) Ein Foundry-Projekt und ein Hub.
(Optional) Eine Verbindung zwischen dem Hub und den Modellen in Foundry.

Voraussetzungen

Um diesen Artikel abzuschließen, benötigen Sie Folgendes:

Ein Azure-Abonnement. Wenn Sie GitHub Models verwenden, können Sie Ihre Erfahrung aktualisieren und ein Azure-Abonnement im Prozess erstellen. Lesen Sie Upgrade von GitHub Models auf Foundry wenn dies der Fall ist.

Ressourcen erstellen

Führen Sie die folgenden Schritte aus, um ein Projekt mit einer Microsoft Foundry-Ressource (früher bekannt Azure AI Services) zu erstellen:

Wechseln Sie zum Foundry-Portal.
Wählen Sie auf der Startseite " Projekt erstellen" aus.
Geben Sie dem Projekt einen Namen, z. B. "my-project".
In diesem Lernprogramm erstellen wir ein völlig neues Projekt unter einem neuen KI-Hub, daher wählen Sie "Neuen Hub erstellen" aus.
Geben Sie dem Hub einen Namen, z. B. "my-hub", und wählen Sie "Weiter" aus.
Der Assistent aktualisiert mit Details zu den Ressourcen, die erstellt werden sollen. Wählen Sie Azure Ressourcen aus, die erstellt werden sollen um die Details anzuzeigen.

Sie können sehen, dass die folgenden Ressourcen erstellt werden:

Eigenschaft	Beschreibung
Ressourcengruppe	Der Hauptcontainer für alle Ressourcen in Azure. Dies hilft, Ressourcen, die zusammenarbeiten, zu organisieren. Es hilft auch, einen Umfang für die Kosten zu haben, die mit dem gesamten Projekt verbunden sind.
Lage	Die Region der Ressourcen, die Sie erstellen.
Hub	Der Hauptcontainer für KI-Projekte in Foundry. Hubs fördern die Zusammenarbeit und ermöglichen es Ihnen, Informationen für Ihre Projekte zu speichern.
Giesserei	In diesem Lernprogramm wird ein neues Konto erstellt, aber Foundry Services können für mehrere Hubs und Projekte freigegeben werden. Hubs verwenden eine Verbindung mit der Ressource, um Zugriff auf die dort verfügbaren Modellbereitstellungen zu haben. Um zu erfahren, wie Sie Verbindungen zwischen Projekten und Foundry erstellen können, um Foundry-Modelle zu nutzen, können Sie Ihr KI-Projekt verbinden.

Wählen Sie "Erstellen" aus. Der Ressourcenerstellungsprozess wird gestartet.
Nach Abschluss des Vorgangs kann Ihr Projekt konfiguriert werden.
Um Foundry Models zu verwenden, müssen Sie Modellbereitstellungen hinzufügen.

Nächste Schritte

Hinzufügen und Konfigurieren von Modellen

Sie können entscheiden und konfigurieren, welche Modelle für die Ableitung in Ihrer Microsoft Foundry-Ressource verfügbar sind. Wenn Sie ein Modell konfigurieren, können Sie Vorhersagen daraus generieren, indem Sie den Modellnamen oder den Bereitstellungsnamen in Ihren Anforderungen angeben. Sie müssen keine weiteren Änderungen an Ihrem Code vornehmen, um das Modell zu verwenden.

In diesem Artikel erfahren Sie, wie Sie einem Foundry Models-Endpunkt ein neues Modell hinzufügen.

Voraussetzungen

Um diesen Artikel abzuschließen, benötigen Sie Folgendes:

Ein Azure-Abonnement. Wenn Sie GitHub Models verwenden, können Sie Ihre Erfahrung aktualisieren und ein Azure-Abonnement im Prozess erstellen. Lesen Sie Upgrade von GitHub Modellen auf Foundry Models wenn dies der Fall ist.
Ein Foundry-Projekt. Diese Art von Projekt wird unter einer Foundry-Ressource verwaltet (früher bekannt als Azure AI Services-Ressource). Wenn Sie nicht über ein Foundry-Projekt verfügen, lesen Sie Create a project for Microsoft Foundry.
Foundry-Modelle von Partnern und Community benötigen Zugriff auf Azure Marketplace. Stellen Sie sicher, dass Sie über die erforderlichen Berechtigungen zum Abonnieren von Modellangeboten verfügen. Foundry Models, die direkt von Azure haben diese Anforderung nicht.
Installieren Sie die Azure CLI und die erweiterung cognitiveservices für Foundry Tools.
```
az extension add -n cognitiveservices
```
Einige der Befehle in diesem Lernprogramm verwenden das jq Tool, das möglicherweise nicht auf Ihrem System installiert ist. Installationsanweisungen finden Sie unter Download jq.
Identifizieren Sie die folgenden Informationen:
- Ihre Azure-Abonnement-ID.
- Der Ressourcenname Ihrer Foundry-Tools.
- Die Ressourcengruppe, in der Sie die Ressource "Foundry Tools" bereitgestellt haben.

Hinzufügen von Modellen

Um ein Modell hinzuzufügen, identifizieren Sie zuerst das Modell, das Sie bereitstellen möchten. Sie können die verfügbaren Modelle wie folgt abfragen:

Melden Sie sich bei Ihrem Azure-Abonnement an.
```
az login
```
Wenn Sie über mehrere Abonnements verfügen, wählen Sie das Abonnement aus, in dem sich Ihre Ressource befindet.
```
az account set --subscription $subscriptionId
```
Legen Sie die folgenden Umgebungsvariablen mit dem Namen der Ressource "Foundry Tools" fest, die Sie verwenden möchten, und die Ressourcengruppe.
```
accountName="<ai-services-resource-name>"
resourceGroupName="<resource-group>"
location="eastus2"
```

Wenn Sie noch kein Foundry Tools-Konto erstellt haben, erstellen Sie ein Konto.

az cognitiveservices account create -n $accountName -g $resourceGroupName --custom-domain $accountName --location $location --kind AIServices --sku S0

Überprüfen Sie, welche Modelle für Sie verfügbar sind und unter welcher SKU. SKUs, auch bekannt als deployment types, definieren, wie Azure Infrastruktur zum Verarbeiten von Anforderungen verwendet wird. Modelle bieten möglicherweise unterschiedliche Bereitstellungstypen an. Der folgende Befehl listet alle verfügbaren Modelldefinitionen auf:
```
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 }'
```

Ausgaben sehen wie folgt aus:

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

Identifizieren Sie das Modell, das Sie bereitstellen möchten. Sie benötigen die Eigenschaften name, format, , versionund sku. Die Eigenschaft format gibt den Anbieter an, der das Modell anbietet. Je nach Bereitstellungstyp benötigen Sie möglicherweise auch Kapazität.

Fügen Sie der Ressource die Modellbereitstellung hinzu. Im folgenden Beispiel wird Phi-3.5-vision-instruct hinzugefügt:

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

Das Modell ist einsatzbereit.

Sie können dasselbe Modell bei Bedarf mehrmals bereitstellen, solange es sich unter einem anderen Bereitstellungsnamen befindet. Diese Funktion kann nützlich sein, wenn Sie verschiedene Konfigurationen für ein bestimmtes Modell testen möchten, einschließlich Inhaltsfiltern.

Modell verwenden

Bereitgestellte Modelle können mithilfe des Azure KI-Modellendpunkts für die Ressource konsumiert werden. Geben Sie beim Erstellen Ihrer Anforderung den Parameter model an, und fügen Sie den erstellten Modellbereitstellungsnamen ein. Sie können den URI für den Ableitungsendpunkt programmgesteuert mit dem folgenden Code abrufen:

Ableitungsendpunkt

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

Um Anforderungen an den Endpunkt Microsoft Foundry Models zu stellen, fügen Sie die Route models an, z. B. https://<resource>.services.ai.azure.com/models. Die API-Referenz für den Endpunkt finden Sie auf Azure AI Model Inference API-Referenzseite.

Inference-Schlüssel

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

Verwalten von Bereitstellungen

Sie können alle Bereitstellungen sehen, die über die CLI verfügbar sind.

Führen Sie den folgenden Befehl aus, um alle aktiven Bereitstellungen anzuzeigen:

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

Sie können die Details einer bestimmten Bereitstellung anzeigen:

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

Sie können eine bestimmte Bereitstellung wie folgt löschen:

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

Wichtig

In diesem Artikel erfahren Sie, wie Sie die ressourcen erstellen, die zum Verwenden Microsoft Foundry Models in Ihren Projekten erforderlich sind.

Grundlegendes zu den Ressourcen

Das Lernprogramm hilft Ihnen beim Erstellen von:

Eine Foundry-Ressource.
Eine Modellbereitstellung für jedes der Modelle, die mit serverlosen API-Bereitstellungen unterstützt werden.
(Optional) Ein Foundry-Projekt und ein Hub.
(Optional) Eine Verbindung zwischen dem Hub und den Modellen in Foundry.

Voraussetzungen

Um diesen Artikel abzuschließen, benötigen Sie Folgendes:

Ein Azure-Abonnement. Wenn Sie GitHub Models verwenden, können Sie Ihre Erfahrung aktualisieren und ein Azure-Abonnement im Prozess erstellen. Lesen Sie Upgrade von GitHub Models auf Foundry wenn dies der Fall ist.

Installieren Sie die Azure CLI.
Identifizieren Sie die folgenden Informationen:
- Ihre Azure-Abonnement-ID.

Informationen zu diesem Tutorial

Das Beispiel in diesem Artikel basiert auf Codebeispielen im Repository Azure-Samples/azureai-model-inference-bicep. Um die Befehle lokal auszuführen, ohne Dateiinhalte kopieren oder einfügen zu müssen, verwenden Sie die folgenden Befehle, um das Repository zu klonen und zum Ordner für Ihre Codierungssprache zu wechseln:

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

Die Dateien für dieses Beispiel sind in:

cd azureai-model-inference-bicep/infra

Foundry-Modelle von Partnern und der Community, die für die Bereitstellung verfügbar sind (z. B. Cohere-Modelle), erfordern den Azure Marketplace. Modellanbieter definieren die Lizenzbedingungen und legen den Preis für die Verwendung ihrer Modelle mithilfe von Azure Marketplace fest.

Stellen Sie beim Bereitstellen von Drittanbietermodellen sicher, dass Sie über die folgenden Berechtigungen in Ihrem Konto verfügen:

Im Azure-Abonnement:
- Microsoft.MarketplaceOrdering/agreements/offers/plans/read
- Microsoft.MarketplaceOrdering/agreements/offers/plans/sign/action
- Microsoft.MarketplaceOrdering/offerTypes/publishers/offers/plans/agreements/read
- Microsoft.Marketplace/offerTypes/publishers/offers/plans/agreements/read
- Microsoft.SaaS/register/action
Auf der Ressourcengruppe – zur Erstellung und Nutzung der SaaS-Ressource:
- Microsoft.SaaS/resources/read
- Microsoft.SaaS/resources/write

Die Owner und Contributor integrierte Rollen im Azure-Abonnement enthalten diese Berechtigungen. Wenn Sie nicht über die erforderlichen Berechtigungen verfügen, bitten Sie Ihren Abonnementadministrator, Ihnen die Rolle " Mitwirkender " zuzuweisen, oder erstellen Sie eine benutzerdefinierte Rolle , die die aufgeführten Aktionen enthält.

Um Ihre Berechtigungen zu überprüfen, wechseln Sie zum Portal Azure, öffnen Sie Ihr Abonnement, wählen Sie Access Control (IAM)>Check access aus, und überprüfen Sie Ihre zugewiesenen Rollen.

Tipp

Microsoft.SaaS/register/action ist eine einmalige Registrierung des SaaS-Ressourcenanbieters für das Abonnement. Nach der Registrierung muss sie für jede Bereitstellung nicht wiederholt werden.

Ressourcen erstellen

Führen Sie die folgenden Schritte aus:

Verwenden Sie die Vorlage modules/ai-services-template.bicep , um Die Ressource "Foundry Tools" zu beschreiben:

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

Verwenden Sie die Vorlage modules/ai-services-deployment-template.bicep, um Modellbereitstellungen zu beschreiben:

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'
  'xAI'
  'Meta'
  'Microsoft'
  'Mistral AI'
  'OpenAI'
])
@description('Model provider')
param modelPublisherFormat string

@allowed([
    'GlobalStandard'
    'DataZoneStandard'
    '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
  }
}

Aus Gründen der Einfachheit definieren wir das Modell, das wir im Dienst mit einer JSON-Datei zur Verfügung haben möchten. Die Datei infra/models.json enthält eine Liste des JSON-Objekts mit Schlüsseln name,version, provider und sku, die die Modelle definiert, die die Bereitstellung bereitstellen wird. Da die Modelle serverlose API-Bereitstellungen unterstützen, verursacht das Hinzufügen von Modellbereitstellungen keine zusätzlichen Kosten. Ändern Sie die Datei, indem Sie die Modelleinträge entfernen/hinzufügen, die Verfügbar sein sollen. Das folgende Beispiel zeigt nur die ersten 7 Zeilen der JSON-Datei:

models.json
```
[
  {
    "name": "Cohere-command-a",
    "version": "1",
    "provider": "Cohere",
    "sku": "GlobalStandard"
  },
```

Wenn Sie Projekte verwenden möchten (empfohlen), benötigen Sie die Vorlagen zum Erstellen eines Projekts, eines Hubs und einer Verbindung mit der Ressource "Foundry Tools":

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

Definieren Sie die Hauptbereitstellung:

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

Melden Sie sich bei Azure an:
```
az login
```
Stellen Sie sicher, dass Sie sich im richtigen Abonnement befinden:
```
az account set --subscription "<subscription-id>"
```

Starten Sie die Bereitstellung:

RESOURCE_GROUP="<resource-group-name>"

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

Wenn Sie nur die Ressource "Foundry Tools" und die Modellbereitstellungen bereitstellen möchten, verwenden Sie die folgende Bereitstellungsdatei:

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

Starten Sie die Bereitstellung:

RESOURCE_GROUP="<resource-group-name>"

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

Die Vorlage gibt den Endpunkt Microsoft Foundry Models aus, den Sie verwenden können, um alle erstellten Modellbereitstellungen zu nutzen.

Nächste Schritte

Feedback

War diese Seite hilfreich?

Last updated on 2026-04-29

Erstellen und Konfigurieren aller Ressourcen für Microsoft Foundry Models

Grundlegendes zu den Ressourcen

Voraussetzungen

Ressourcen erstellen

Nächste Schritte

Voraussetzungen

Hinzufügen von Modellen

Modell verwenden

Verwalten von Bereitstellungen

Grundlegendes zu den Ressourcen

Voraussetzungen

Informationen zu diesem Tutorial

Berechtigungen, die zum Abonnieren von Modellen von Partnern und der Community erforderlich sind

Ressourcen erstellen

Nächste Schritte

Feedback

Zusätzliche Ressourcen