Compartilhar via

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

  • Artigo

Importante

Os itens marcados (versão prévia) neste artigo estão atualmente em versão prévia pública. Essa versão prévia é fornecida sem um contrato de nível de serviço e não recomendamos isso para cargas de trabalho de produção. Alguns recursos podem não ter suporte ou podem ter restrição de recursos. Para obter mais informações, consulte Termos de Uso Complementares de Versões Prévias do Microsoft Azure.

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

Pré-requisitos

Para concluir este artigo, você precisa do seguinte:

Importante

O portal da Fábrica de IA do Azure usa projetos e hubs para criar contas dos Serviços de IA do Azure e configurar a inferência do modelo de IA do Azure. Se você não quiser usar hubs e projetos, poderá criar os recursos usando a CLI do Azure, o Bicep ou criar recursos dos 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. Acesse o portal do IA do Azure Foundry.

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

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

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

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

  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:

    Propriedade Descrição
    Grupo de recursos O contêiner principal para todos os recursos no Azure. Isso ajuda a organizar os recursos que funcionam juntos. Ele também ajuda a ter um escopo para os custos associados a todo o projeto.
    Localidade A região dos recursos que você está criando.
    Hub O contêiner principal para projetos de IA na Fábrica de IA do Azure. Os hubs promovem a colaboração e permitem que você armazene informações para seus projetos.
    Serviços de IA O recurso que habilita o acesso aos modelos principais 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 em 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 do 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. Depois de concluído, seu projeto está pronto para ser configurado.

  10. A inferência do modelo de IA do Azure é uma versão prévia do recurso que precisa ser ativado na Fábrica de IA do Azure. Na barra de navegação superior, no canto superior direito, selecione o ícone Recursos de visualização. Uma folha 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 modelos de implantação do serviço de inferência do modelo de IA do Azure no portal da Fábrica de IA do Azure.

  12. Feche o painel.

  13. Para usar a inferência do 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 (versão prévia) neste artigo estão atualmente em versão prévia pública. Essa versão prévia é fornecida sem um contrato de nível de serviço e não recomendamos isso para cargas de trabalho de produção. Alguns recursos podem não ter suporte ou podem ter restrição de recursos. Para obter mais informações, consulte Termos de Uso Complementares de Versões Prévias 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 está configurado, você pode então gerar previsões a partir dele indicando seu nome de modelo ou nome de implantação nas suas solicitações. Nenhuma outra alteração é necessária no seu código para usá-lo.

Neste artigo, você aprenderá a adicionar um novo modelo à inferência do modelo de IA do Azure na Fábrica de IA do Azure.

Pré-requisitos

Para concluir este artigo, você precisa do seguinte:

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

    az extension add -n cognitiveservices

  • Alguns dos comandos deste tutorial usam a ferramenta jq, que pode não estar instalada em seu sistema. Para obter instruções de instalação, confira Baixar jq.

  • Identifique as seguintes informações:

    • Sua ID da assinatura do Azure.

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

    • O grupo de recursos em que 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. Faça logon em sua assinatura do Azure:

    az login

  2. Se você tiver mais de 1 assinatura, selecione a assinatura na qual o recurso está localizado:

    az account set --subscription $subscriptionId>

  3. Defina as variáveis de ambiente a seguir com o nome do recurso dos Serviços de IA do Azure que você planeja usar e 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 em 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 são as seguintes:

    {
  "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.

    Dica

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

  8. Adicione a implantação de 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 ele esteja em um nome de implantação diferente. Essa funcionalidade pode ser útil caso você queira testar configurações diferentes para um determinado modelo, incluindo a segurança do conteúdo.

Administrar 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

Usar 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 de extremidade 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 de API de inferência do modelo de IA do Azure.

Chaves de inferência

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

Importante

Os itens marcados (versão prévia) neste artigo estão atualmente em versão prévia pública. Essa versão prévia é fornecida sem um contrato de nível de serviço e não recomendamos isso para cargas de trabalho de produção. Alguns recursos podem não ter suporte ou podem ter restrição de recursos. Para obter mais informações, consulte Termos de Uso Complementares de Versões Prévias do Microsoft Azure.

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

Pré-requisitos

Para concluir este artigo, você precisa do seguinte:

  • Instale a CLI do Azure.

  • Identifique as seguintes informações:

    • Sua ID da assinatura do Azure.

Sobre este tutorial

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

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

Os arquivos desse exemplo estão em:

cd azureai-model-inference-bicep/infra

Entenda os recursos

O tutorial ajuda você a criar:

  • Um recurso dos Serviços de IA do Azure.
  • Uma implantação de modelo na SKU padrão global para cada um dos modelos que dão suporte ao 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 o recurso dos Serviços de IA do Azure:

    modules/ai-services-template.bicep

    @description('Location of the resource.')
param location string = resourceGroup().location

@description('Name of the Azure AI Services account.')
param accountName string

@description('The resource model definition representing SKU')
param sku string = 'S0'

@description('Whether or not to allow keys for this account.')
param allowKeys bool = true

@allowed([
  'Enabled'
  'Disabled'
])
@description('Whether or not public endpoint access is allowed for this account.')
param publicNetworkAccess string = 'Enabled'

@allowed([
  'Allow'
  'Deny'
])
@description('The default action for network ACLs.')
param networkAclsDefaultAction string = 'Allow'

resource account 'Microsoft.CognitiveServices/accounts@2023-05-01' = {
  name: accountName
  location: location
  identity: {
    type: 'SystemAssigned'
  }
  sku: {
    name: sku
  }
  kind: 'AIServices'
  properties: {
    publicNetworkAccess: publicNetworkAccess
    networkAcls: {
      defaultAction: networkAclsDefaultAction
    }
    disableLocalAuth: allowKeys
  }
}

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

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

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

  3. Por conveniência, definimos o modelo que desejamos ter disponível no serviço usando um arquivo JSON. O arquivo infra/models.json contém uma lista de objetos JSON com chaves name, version, provider e sku, que define os modelos que a implantação provisionará. Como os modelos dão suporte ao pagamento conforme o uso, a adição de implantações de modelo não incorre em custo extra. Modifique o arquivo removendo/adicionando as entradas de modelo que você deseja ter disponíveis. O exemplo a seguir mostra apenas as sete primeiras 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, um hub e uma conexão com o recurso dos Serviços de IA do Azure:

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

Criar os recursos

No console, siga estas etapas:

  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. Verifique se você está na assinatura 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óximas etapas