Erstellen und Konfigurieren aller Ressourcen für Microsoft Foundry Models

Hinweis

Dieses Dokument bezieht sich auf das Microsoft Foundry(klassische) Portal.

🔍 Zeigen Sie die Microsoft Foundry-Dokumentation (neu) an, um mehr über das neue Portal zu erfahren.

Von Bedeutung

Die in diesem Artikel markierten Elemente (Vorschau) sind aktuell als öffentliche Vorschau verfügbar. Diese Vorschauversion wird ohne Vereinbarung zum Servicelevel bereitgestellt und sollte nicht für Produktionsworkloads verwendet werden. Manche Features werden möglicherweise nicht unterstützt oder sind nur eingeschränkt verwendbar. Weitere Informationen finden Sie unter Zusätzliche Nutzungsbestimmungen für Microsoft Azure-Vorschauen.

In diesem Artikel erfahren Sie, wie Sie die ressourcen erstellen, die für die Verwendung von Microsoft Foundry Models in Ihren Projekten erforderlich sind.

Grundlegendes zu den Ressourcen

Foundry Models ist eine Funktion in Foundry Services (früher bekannt als Azure AI Services). Sie können Modellbereitstellungen unter der Ressource erstellen, um ihre Vorhersagen zu nutzen. Sie können die Ressource auch mit Azure AI Hubs und Projekten 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.

Dieses Tutorial unterstütz Sie beim Erstellen der folgenden Elemente:

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

Damit Sie die Anweisungen in diesem Artikel ausführen können, benötigen Sie Folgendes:

Ein Azure-Abonnement. Wenn Sie GitHub-Modelle verwenden, können Sie Ihre Erfahrung upgraden und während dem Prozess ein Azure-Abonnement erstellen. Lesen Sie das Upgrade von GitHub-Modellen auf Foundry , wenn dies Ihr Fall ist.

Ressourcen erstellen

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

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

Sie sehen, dass die folgenden Ressourcen erstellt werden:

Eigentum	BESCHREIBUNG
Ressourcengruppe	Der Hauptcontainer für alle Ressourcen in Azure. Dadurch können Ressourcen organisiert werden, die zusammenarbeiten. Es hilft auch dabei, einen Überblick über die Kosten zu haben, die mit dem gesamten Projekt verbunden sind.
Standort	Die Region der Ressourcen, die Sie erstellen.
Drehscheibe	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.
Gießerei	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 Prozess zur Ressourcenerstellung wird gestartet.
Nach Abschluss des Vorgangs kann Ihr Projekt konfiguriert werden.
Um Foundry Models zu verwenden, müssen Sie Modellimplementierungen 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

Damit Sie die Anweisungen in diesem Artikel ausführen können, benötigen Sie Folgendes:

Ein Azure-Abonnement. Wenn Sie GitHub-Modelle verwenden, können Sie Ihre Erfahrung upgraden und während dem Prozess ein Azure-Abonnement erstellen. Lesen Sie Upgrade von GitHub-Modellen auf Foundry-Modelle, wenn dies der Fall ist.
Ein Foundry-Projekt. Diese Art von Projekt wird unter einer Foundry-Ressource (früher als Azure AI Services-Ressource bezeichnet) verwaltet. Wenn Sie nicht über ein Foundry-Projekt verfügen, lesen Sie " Erstellen eines Projekts für Foundry (Foundry-Projekte)".
Foundry Models von Partnern und der Community erfordern einen Zugriff auf Azure Marketplace. Stellen Sie sicher, dass Sie über die erforderlichen Berechtigungen zum Abonnieren von Modellangeboten verfügen. Für Foundry Models, die direkt von Azure verkauft werden, besteht diese Anforderung nicht.

Installieren Sie die Azure CLI und die cognitiveservices Erweiterung 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. Die Installationsanweisungen finden Sie unter Download jq.
Ermitteln Sie die folgenden Informationen:
- die Azure-Abonnement-ID
- Foundry Tools Ressourcenname
- Die Ressourcengruppe, in der Sie die Ressource "Foundry Tools" bereitgestellt haben.

Modelle hinzufügen

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 als Bereitstellungstypen bezeichnet, 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 }'
```

Die Ausgabe sieht 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, version und 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 Modellimplementierung 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 dies unter einem anderen Bereitstellungsnamen erfolgt. Diese Funktion kann nützlich sein, wenn Sie verschiedene Konfigurationen für ein bestimmtes Modell testen möchten, einschließlich Inhaltsfiltern.

Verwenden Sie das Modell

Bereitgestellte Modelle können mithilfe des Rückschlussendpunkts des Azure KI-Modells für die Ressource genutzt werden. Geben Sie beim Erstellen Ihrer Anforderung den Parameter model an, und fügen Sie den von Ihnen erstellten Namen der Modellimplementierung ein. Sie können den URI für den Rückschlussendpunkt mithilfe des folgenden Codes programmgesteuert abrufen:

Inference-Endpunkt

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

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

Inferenzschlüssel

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

Verwalten von Bereitstellungen

Mithilfe der CLI können Sie alle verfügbaren Bereitstellungen anzeigen:

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

Von Bedeutung

In diesem Artikel erfahren Sie, wie Sie die ressourcen erstellen, die für die Verwendung von Microsoft Foundry Models in Ihren Projekten erforderlich sind.

Grundlegendes zu den Ressourcen

Dieses Tutorial unterstütz Sie beim Erstellen der folgenden Elemente:

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

Damit Sie die Anweisungen in diesem Artikel ausführen können, benötigen Sie Folgendes:

Ein Azure-Abonnement. Wenn Sie GitHub-Modelle verwenden, können Sie Ihre Erfahrung upgraden und während dem Prozess ein Azure-Abonnement erstellen. Lesen Sie das Upgrade von GitHub-Modellen auf Foundry , wenn dies Ihr Fall ist.

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

Informationen zu diesem Tutorial

Das Beispiel in diesem Artikel basiert auf Codebeispielen, die im Repository Azure-Samples/azureai-model-inference-bicep enthalten sind. Wenn Sie die Befehle lokal ausführen möchten, 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 Programmiersprache zu wechseln:

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

Die Dateien für dieses Beispiel befinden sich in:

cd azureai-model-inference-bicep/infra

Foundry-Modelle von Partnern und der Community stehen für den die Bereitstellung zur Verfügung (zum Beispiel Cohere-Modelle) erfordern 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
In der Ressourcengruppe zum Erstellen und Verwenden der SaaS-Ressource:
- Microsoft.SaaS/resources/read
- Microsoft.SaaS/resources/write

Ressourcen erstellen

Folgen Sie diesen Schritten:

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 Bereitstellungen von Modellen 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
  }
}

Der Einfachheit halber definieren wir das Modell, das im Dienst verfügbar sein soll, mithilfe einer JSON-Datei. Die Datei infra/models.json enthält eine Liste von JSON-Objekten mit den Schlüsseln name, version, provider und sku, die die bereitzustellenden Modelle definiert. 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. Im folgenden Beispiel werden nur die ersten 7 Zeilen der JSON-Datei angezeigt:

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>"
```

Führen Sie die Bereitstellung aus:

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

Führen Sie die Bereitstellung aus:

RESOURCE_GROUP="<resource-group-name>"

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

Die Vorlage gibt den Microsoft Foundry Models-Endpunkt aus, den Sie verwenden können, um eine der modellbasierten Bereitstellungen zu nutzen, die Sie erstellt haben.

Nächste Schritte

Verwenden des Rückschlussendpunkts

Feedback

War diese Seite hilfreich?

Last updated on 2025-11-18

Freigeben über

Erstellen und Konfigurieren aller Ressourcen für Microsoft Foundry Models

Grundlegendes zu den Ressourcen

Voraussetzungen

Ressourcen erstellen

Nächste Schritte

Voraussetzungen

Modelle hinzufügen

Verwenden Sie das Modell

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