Alle resources voor Azure AI Foundry-modellen maken en configureren

2025-06-26

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. Bepaalde functies worden mogelijk niet ondersteund of hebben mogelijk beperkte mogelijkheden. Voor meer informatie, zie Aanvullende Gebruiksvoorwaarden voor Microsoft Azure Previews.

In dit artikel leert u hoe u de resources maakt die nodig zijn voor het gebruik van Azure AI Foundry-modellen in uw projecten.

Begrijp de resources

Azure AI Foundry Models is een mogelijkheid in Azure AI Foundry Services (voorheen Bekend als Azure AI Services). U kunt modelimplementaties onder de resource maken om de voorspellingen te benutten. U kunt de resource ook verbinden met Azure AI Hubs en Projecten in Azure AI Foundry om zo nodig intelligente toepassingen te maken. In de volgende afbeelding ziet u de architectuur op hoog niveau.

Azure AI Foundry Services vereist geen AI-projecten of AI-hubs om te werken en u kunt ze maken om vlaggenschipmodellen van uw toepassingen te gebruiken. Er zijn echter extra mogelijkheden beschikbaar als u een Azure AI-project en -hub implementeert, inclusief speeltuin of agents.

De handleiding helpt u bij het maken van:

Een Azure AI Foundry-resource.
Een modelimplementatie voor elk van de modellen die worden ondersteund met serverloze API-implementaties.
(Optioneel) Een Azure AI-project en -hub.
(Optioneel) Een verbinding tussen de hub en de modellen in Azure AI Foundry.

Vereiste voorwaarden

U hebt het volgende nodig om dit artikel te voltooien:

Een Azure-abonnement. Als je GitHub Models gebruikt, kun je je ervaring verbeteren en in het proces een Azure-abonnement aanmaken. Lees de upgrade van GitHub-modellen naar Azure AI Foundry als dat uw geval is.

Maak de resources aan

Volg deze stappen om een project te maken met een Azure AI Foundry-resource (voorheen bekend als Azure AI Services):

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 en daarom selecteren we Nieuwe hub maken onder een nieuwe AI-hub.
Geef de hub een naam, bijvoorbeeld 'my-hub' en selecteer Volgende.
De wizard wordt bijgewerkt met details over de resources die aangemaakt gaan worden. Selecteer Azure-resources die moeten worden gemaakt om de details te bekijken.

U kunt zien dat de volgende resources zijn gemaakt:

Vastgoed	Beschrijving
Bronnengroep	De hoofdcontainer voor alle resources in Azure. Dit helpt bij het organiseren van resources die samenwerken. Het helpt ook om een overzicht te hebben van de kosten die aan het hele project zijn verbonden.
Locatie	De regio van de middelen die u aan het maken bent.
Knooppunt	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 Foundry	In deze zelfstudie wordt een nieuw account gemaakt, maar Azure AI Foundry Services kan 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 Foundry om Azure AI Foundry-modellen te gebruiken, kunt u uw AI-project verbinden lezen.

Klik op Creëren. Het aanmaken van resources start.
Zodra het project is voltooid, is het klaar om te worden geconfigureerd.
Als u Azure AI Foundry Models wilt gebruiken, moet u modelimplementaties toevoegen.

Volgende stappen

Modellen toevoegen en configureren

U kunt bepalen en configureren welke modellen beschikbaar zijn voor deductie in uw Azure AI Foundry-resource. 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 Foundry.

Vereiste voorwaarden

U hebt het volgende nodig om dit artikel te voltooien:

Een Azure-abonnement. Als je GitHub Models gebruikt, kun je je ervaring verbeteren en in het proces een Azure-abonnement aanmaken. Lees de upgrade van GitHub-modellen naar Azure AI Foundry-modellen als dat uw geval is.
Een Azure AI Foundry-resource (voorheen Bekend als Azure AI Services). Zie Alle resources voor Azure AI Foundry-modellen maken en configureren voor meer informatie.
Voor modellen van partners en community is toegang tot Azure Marketplace vereist. Zorg ervoor dat u over de vereiste machtigingen beschikt om u te abonneren op modelaanbiedingen. Modellen die rechtstreeks door Azure worden verkocht , hebben deze vereiste niet.

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 naam van uw Azure AI Services-resource.
- 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>"
location="eastus2"
```

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 --custom-domain $accountName --location $location --kind AIServices --sku S0

Laten we eerst kijken welke modellen beschikbaar zijn voor u en onder welke SKU. SKU's, ook wel implementatietypen genoemd, definiëren hoe de Azure-infrastructuur wordt gebruikt voor het verwerken van aanvragen. Modellen kunnen verschillende implementatietypen bieden. 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 }'
```

De 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 eigenschappen name, format, version, en sku. De eigenschap format geeft de provider aan die het model aanbiedt. Capaciteit kan ook nodig zijn, afhankelijk van het type implementatie.

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 handig zijn als u verschillende configuraties voor een bepaald model wilt testen, inclusief inhoudsfilters.

Het model gebruiken

Geïmplementeerde modellen kunnen worden gebruikt via het inferentie-eindpunt van het Azure AI-model dat bij de resource hoort. 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:

Inference-eindpunt

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

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

Deductiesleutels

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

Deployments 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

Belangrijk

In dit artikel leert u hoe u de resources maakt die nodig zijn voor het gebruik van Azure AI Foundry-modellen in uw projecten.

Begrijp de resources

De handleiding helpt u bij het maken van:

Een Azure AI Foundry-resource.
Een modelimplementatie voor elk van de modellen die worden ondersteund met serverloze API-implementaties.
(Optioneel) Een Azure AI-project en -hub.
(Optioneel) Een verbinding tussen de hub en de modellen in Azure AI Foundry.

Vereiste voorwaarden

U hebt het volgende nodig om dit artikel te voltooien:

Een Azure-abonnement. Als je GitHub Models gebruikt, kun je je ervaring verbeteren en in het proces een Azure-abonnement aanmaken. Lees de upgrade van GitHub-modellen naar Azure AI Foundry als dat uw geval is.

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

Over deze handleiding

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

Voor modellen van partners en community's die beschikbaar zijn voor implementatie (bijvoorbeeld Cohere-modellen) is Azure Marketplace vereist. Modelproviders definiëren de licentievoorwaarden en stellen de prijs in voor het gebruik van hun modellen met behulp van Azure Marketplace.

Zorg ervoor dat u bij het implementeren van modellen van derden de volgende machtigingen in uw account hebt:

In het 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 de resourcegroep: om de SaaS-resource te maken en te gebruiken:
- Microsoft.SaaS/resources/read
- Microsoft.SaaS/resources/write

Maak de resources aan

Volg deze stappen:

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: {
    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

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 serverloze API-implementaties ondersteunen, worden er geen extra kosten in rekening gebracht bij het toevoegen van modelimplementaties. Wijzig het bestand door de modelvermeldingen te verwijderen of toe te voegen 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
    }
  }
}

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 azure AI Foundry Models-eindpunt uitgevoerd dat u kunt gebruiken om alle modelimplementaties te gebruiken die u hebt gemaakt.

Volgende stappen

Het deductie-eindpunt gebruiken

Delen via

Alle resources voor Azure AI Foundry-modellen maken en configureren

Begrijp de resources

Vereiste voorwaarden

Maak de resources aan

Volgende stappen

Vereiste voorwaarden

Modellen toevoegen

Het model gebruiken

Deployments beheren

Begrijp de resources

Vereiste voorwaarden

Over deze handleiding

Vereiste machtigingen voor het abonneren op modellen van partners en community

Maak de resources aan

Volgende stappen

Feedback

Aanvullende resources