Partilhar via

Criar e configurar todos os recursos para inferência de modelo de IA do Azure

  • Artigo

Importante

Os itens marcados (visualização) neste artigo estão atualmente em visualização pública. Essa visualização é fornecida sem um contrato de nível de serviço e não a recomendamos para cargas de trabalho de produção. Algumas funcionalidades poderão não ser suportadas ou poderão ter capacidades limitadas. Para obter mais informações, veja Termos Suplementares de Utilização para Pré-visualizações do Microsoft Azure.

Neste artigo, você aprenderá a criar os recursos necessários para usar a inferência de modelo de IA do Azure e consumir modelos emblemáticos do catálogo de modelos de IA do Azure.

Pré-requisitos

Para concluir este artigo, precisa de:

Importante

O portal do Azure AI Foundry usa projetos e hubs para criar contas dos Serviços de IA do Azure e configurar a inferência de modelo de IA do Azure. Se você não quiser usar hubs e projetos, poderá criar os recursos usando a CLI do Azure, o Bíceps ou criar o recurso de serviços de IA do Azure usando o portal do Azure.

Criar os recursos

Para criar um projeto com uma conta dos Serviços de IA do Azure, siga estas etapas:

  1. Vá para o portal do Azure AI Foundry.

  2. Na página de destino, selecione Criar projeto.

  3. Dê um nome ao projeto, por exemplo, "meu-projeto".

  4. Neste tutorial, criamos um novo projeto sob um novo hub de IA, portanto, selecione Criar novo hub.

  5. Dê um nome ao hub, por exemplo, "my-hub" e selecione Next.

  6. O assistente é atualizado com detalhes sobre os recursos que serão criados. Selecione Recursos do Azure a serem criados para ver os detalhes.

    Captura de tela mostrando os detalhes do projeto e do hub a ser criado.

  7. Você pode ver que os seguintes recursos são criados:

    Property Description
    Grupo de recursos O contêiner principal para todos os recursos no Azure. Isso ajuda a organizar os recursos que trabalham juntos. Também ajuda a ter uma margem para os custos associados a todo o projeto.
    Location A região dos recursos que você está criando.
    Hub O contêiner principal para projetos de IA no Azure AI Foundry. Os Hubs promovem a colaboração e permitem que você armazene informações para seus projetos.
    Serviços de IA O recurso que permite o acesso aos modelos emblemáticos no catálogo de modelos de IA do Azure. Neste tutorial, uma nova conta é criada, mas os recursos dos serviços de IA do Azure podem ser compartilhados entre vários hubs e projetos. Os hubs usam uma conexão com o recurso para ter acesso às implantações de modelo disponíveis lá. Para saber como, você pode criar conexões entre projetos e os Serviços de IA do Azure para consumir a inferência de modelo de IA do Azure, você pode ler Conectar seu projeto de IA.

  8. Selecione Criar. O processo de criação de recursos é iniciado.

  9. Uma vez concluído, seu projeto está pronto para ser configurado.

  10. A inferência de modelo de IA do Azure é um recurso de visualização que precisa ser ativado no Azure AI Foundry. Na barra de navegação superior, no canto direito, selecione o ícone Visualizar recursos . Uma lâmina contextual aparece à direita da tela.

  11. Ative o recurso Implantar modelos no serviço de inferência de modelo de IA do Azure.

    Uma animação mostrando como ativar o recurso de implantação de modelos do serviço de inferência de modelo de IA do Azure no portal do Azure AI Foundry.

  12. Feche o painel.

  13. Para usar a inferência de modelo de IA do Azure, você precisa adicionar implantações de modelo à sua conta de serviços de IA do Azure.

    Adicionar e configurar modelos

Importante

Os itens marcados (visualização) neste artigo estão atualmente em visualização pública. Essa visualização é fornecida sem um contrato de nível de serviço e não a recomendamos para cargas de trabalho de produção. Algumas funcionalidades poderão não ser suportadas ou poderão ter capacidades limitadas. Para obter mais informações, veja Termos Suplementares de Utilização para Pré-visualizações do Microsoft Azure.

Você pode decidir e configurar quais modelos estão disponíveis para inferência no ponto de extremidade de inferência. Quando um determinado modelo é configurado, você pode gerar previsões a partir dele, indicando o nome do modelo ou o nome da implantação em suas solicitações. Não são necessárias mais alterações no seu código para usá-lo.

Neste artigo, você aprenderá como adicionar um novo modelo à inferência de modelo de IA do Azure no Azure AI Foundry.

Pré-requisitos

Para concluir este artigo, precisa de:

  • Uma subscrição do Azure. Se você estiver usando Modelos do GitHub, poderá atualizar sua experiência e criar uma assinatura do Azure no processo. Leia Atualização de modelos do GitHub para inferência de modelo de IA do Azure, se esse for o seu caso.

  • Um recurso de serviços de IA do Azure.

  • Instale a CLI do Azure e a extensão para os cognitiveservices Serviços de IA do Azure:

    az extension add -n cognitiveservices

  • Alguns dos comandos neste tutorial usam a jq ferramenta, que pode não estar instalada no seu sistema. Para obter instruções de instalação, consulte Download jq.

  • Identifique as seguintes informações:

    • O seu ID de subscrição do Azure.

    • Seu nome de recurso dos Serviços de IA do Azure.

    • O grupo de recursos onde o recurso dos Serviços de IA do Azure é implantado.

Adicionar modelos

Para adicionar um modelo, primeiro você precisa identificar o modelo que deseja implantar. Você pode consultar os modelos disponíveis da seguinte maneira:

  1. Inicie sessão na sua subscrição do Azure:

    az login

  2. Se tiver mais de 1 subscrição, selecione a subscrição onde o recurso está localizado:

    az account set --subscription $subscriptionId>

  3. Defina as seguintes variáveis de ambiente com o nome do recurso dos Serviços de IA do Azure que você planeja usar e o grupo de recursos.

    accountName="<ai-services-resource-name>"
resourceGroupName="<resource-group>"

  4. Se você ainda não tiver uma conta dos Serviços de IA do Azure criada, poderá criar uma da seguinte maneira:

    az cognitiveservices account create -n $accountName -g $resourceGroupName

  5. Vamos ver primeiro quais modelos estão disponíveis para você e sob qual SKU. O comando a seguir lista todas as definições de modelo disponíveis:

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

  6. As saídas têm a seguinte aparência:

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

  7. Identifique o modelo que você deseja implantar. Você precisa das propriedades name, format, version, e sku. A capacidade também pode ser necessária, dependendo do tipo de implantação.

    Gorjeta

    Observe que nem todos os modelos estão disponíveis em todas as SKUs.

  8. Adicione a implantação do modelo ao recurso. O exemplo a seguir adiciona 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

  9. O modelo está pronto para ser consumido.

Você pode implantar o mesmo modelo várias vezes, se necessário, desde que esteja sob um nome de implantação diferente. Esse recurso pode ser útil caso você queira testar configurações diferentes para um determinado modelo, incluindo segurança de conteúdo.

Gerenciar implantações

Você pode ver todas as implantações disponíveis usando a CLI:

  1. Execute o seguinte comando para ver todas as implantações ativas:

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

  2. Você pode ver os detalhes de uma determinada implantação:

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

  3. Você pode excluir uma determinada implantação da seguinte maneira:

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

Use o modelo

Os modelos implantados na inferência de modelo de IA do Azure podem ser consumidos usando o ponto de extremidade de inferência do modelo de IA do Azure para o recurso. Ao construir sua solicitação, indique o parâmetro model e insira o nome de implantação do modelo que você criou. Você pode obter programaticamente o URI para o ponto de extremidade de inferência usando o seguinte código:

Ponto final de inferência

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

Para fazer solicitações ao ponto de extremidade de inferência do modelo de IA do Azure, acrescente a rota models, por exemplo https://<resource>.services.ai.azure.com/models. Você pode ver a referência de API para o ponto de extremidade na página de referência da API de inferência de modelo de IA do Azure.

Chaves de inferência

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

Importante

Os itens marcados (visualização) neste artigo estão atualmente em visualização pública. Essa visualização é fornecida sem um contrato de nível de serviço e não a recomendamos para cargas de trabalho de produção. Algumas funcionalidades poderão não ser suportadas ou poderão ter capacidades limitadas. Para obter mais informações, veja Termos Suplementares de Utilização para Pré-visualizações do Microsoft Azure.

Neste artigo, você aprenderá a criar os recursos necessários para usar a inferência de modelo de IA do Azure e consumir modelos emblemáticos do catálogo de modelos de IA do Azure.

Pré-requisitos

Para concluir este artigo, precisa de:

  • Instale a CLI do Azure.

  • Identifique as seguintes informações:

    • O seu ID de subscrição do Azure.

Acerca deste tutorial

O exemplo neste artigo é baseado em exemplos de código contidos no repositório Azure-Samples/azureai-model-inference-bicep . Para executar os comandos localmente sem ter que copiar ou colar o conteúdo do arquivo, use os seguintes comandos para clonar o repositório e vá para a pasta do seu idioma de codificação:

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

Os arquivos para este exemplo estão em:

cd azureai-model-inference-bicep/infra

Compreender os recursos

O tutorial ajuda você a criar:

  • Um recurso dos Serviços de IA do Azure.
  • Uma implantação de modelo no SKU padrão global para cada um dos modelos que suportam pagamento conforme o uso.
  • (Opcionalmente) Um projeto e hub de IA do Azure.
  • (Opcionalmente) Uma conexão entre o hub e os modelos nos Serviços de IA do Azure.

Você está usando os seguintes ativos para criar esses recursos:

  1. Use o modelo modules/ai-services-template.bicep para descrever seu recurso dos Serviços de IA do Azure:

    módulos/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

  2. Use o modelo modules/ai-services-deployment-template.bicep para descrever implantações de modelo:

    módulos/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
  }
}

  3. Por conveniência, definimos o modelo que queremos ter disponível no serviço usando um arquivo JSON. O arquivo infra/models.json contém uma lista de objeto JSON com chaves name,version, providere sku, que define os modelos que a implantação irá provisionar. Como os modelos suportam pagamento conforme o uso, adicionar implantações de modelo não implica em custo extra. Modifique o arquivo removendo/adicionando as entradas do modelo que você deseja ter disponíveis. O exemplo a seguir mostra apenas as primeiras 7 linhas do arquivo JSON:

    models.json

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

  4. Se você planeja usar projetos (recomendado), precisará dos modelos para criar um projeto, hub e uma conexão com o recurso dos Serviços de IA do Azure:

    módulos/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
}

    módulos/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
    }
  }
}

Criar os recursos

Na consola, siga estes passos:

  1. Defina a implantação principal:

    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

  2. Faça logon no Azure:

    az login

  3. Certifique-se de que tem a subscrição certa:

    az account set --subscription "<subscription-id>"

  4. Execute a implantação:

    RESOURCE_GROUP="<resource-group-name>"

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

  5. Se você quiser implantar apenas o recurso dos Serviços de IA do Azure e as implantações de modelo, use o seguinte arquivo de implantação:

    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

  6. Execute a implantação:

    RESOURCE_GROUP="<resource-group-name>"

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

  7. O modelo gera o ponto de extremidade de inferência do modelo de IA do Azure que você pode usar para consumir qualquer uma das implantações de modelo que você criou.

Próximos passos