Creación y configuración de todos los recursos para la inferencia de modelos de Azure AI

Artículo
01/29/2025

Importante

Los elementos marcados (versión preliminar) en este artículo se encuentran actualmente en versión preliminar pública. Esta versión preliminar se ofrece sin acuerdo de nivel de servicio y no se recomienda para las cargas de trabajo de producción. Es posible que algunas características no sean compatibles o que tengan sus funcionalidades limitadas. Para más información, consulte Términos de uso complementarios de las Versiones Preliminares de Microsoft Azure.

En este artículo, aprenderá a crear los recursos necesarios para usar la inferencia del modelo de Azure AI y a consumir modelos insignia del catálogo de modelos de Azure AI.

Requisitos previos

Para completar este artículo, necesitará lo siguiente:

Suscripción a Azure. Si usa Modelos de GitHub, puede actualizar la experiencia y crear una suscripción de Azure en el proceso. Lea Actualización de modelos de GitHub a la inferencia de modelos de Azure AI si es su caso.

Importante

El Portal de la Fundición de IA de Azure usa proyectos y centros para crear cuentas de Servicios de Azure AI y configurar la inferencia del modelo de Azure AI. Si no desea usar centros y proyectos, puede crear los recursos mediante la CLI de Azure, Bicep o crear el recurso de servicios de Azure AI mediante Azure Portal.

Creación de los recursos

Para crear un proyecto con una cuenta de Servicios de Azure AI, siga estos pasos:

Visite el portal de Azure AI Foundry.
En la página de aterrizaje, seleccione Crear proyecto.
Asigne un nombre al proyecto, por ejemplo, "my-project".
En este tutorial, crearemos un proyecto nuevo en un nuevo centro de IA, por lo tanto, seleccione Crear nuevo centro.
Asigne un nombre al centro, por ejemplo, "my-hub" y seleccione Siguiente.
El asistente se actualiza con los detalles sobre los recursos que se van a crear. Seleccione los recursos de Azure que se van a crear para ver los detalles.

Puede ver que se crean los siguientes recursos:

Propiedad	Descripción
Grupos de recursos	El contenedor principal para todos los recursos de Azure. Esto ayuda a organizar los recursos que funcionan juntos. También ayuda a tener un ámbito para los costos asociados a todo el proyecto.
Location	La región de los recursos que va a crear.
Hub	El contenedor principal para los proyectos de IA en Fundición de IA de Azure. Los centros promueven la colaboración y permiten almacenar información para los proyectos.
AI Services	El recurso que habilita el acceso a los modelos insignia en el catálogo de modelos de Azure AI. En este tutorial, se crea una nueva cuenta, pero los recursos de los servicios de Azure AI se pueden compartir entre varios centros y proyectos. Los centros usan una conexión al recurso para tener acceso a las implementaciones de modelo disponibles allí. Para obtener información sobre cómo puede crear conexiones entre los proyectos y los Servicios de Azure AI para consumir la inferencia del modelo de Azure AI, puede leer Conexión del proyecto de IA.

Seleccione Crear. Se inicia el proceso de creación de recursos.
Una vez completado, el proyecto está listo para configurarse.
La inferencia de modelos de Azure AI es una característica en vista previa que debe activarse en Fundición de IA de Azure. En la barra de navegación superior, en la esquina derecha, seleccione el icono Características de vista previa. Aparece una hoja contextual a la derecha de la pantalla.
Active la característica Implementación de modelos en el servicio de la inferencia del modelo de Azure AI.
Cierre el panel.
Para usar la inferencia de modelos de Azure AI, debe agregar implementaciones de modelos a la cuenta de servicios de Azure AI.

Agregar y configurar el módulo

Importante

Puede decidir y configurar qué modelos están disponibles para la inferencia en el punto de conexión de la inferencia. Cuando se configura un modelo determinado, puede generar predicciones a partir de él si indica su nombre de modelo o nombre de implementación en las solicitudes. No se requieren más cambios en el código para usarlo.

En este artículo, aprenderá a agregar un nuevo modelo a la inferencia de modelos de Azure AI en la Fundición de IA de Azure.

Requisitos previos

Para completar este artículo, necesitará lo siguiente:

Suscripción a Azure. Si usa Modelos de GitHub, puede actualizar la experiencia y crear una suscripción de Azure en el proceso. Lea Actualización de modelos de GitHub a la inferencia de modelos de Azure AI si es su caso.
Recurso de Servicios de Azure AI.

Instale la CLI de Azure y la extensión de cognitiveservices para Servicios de Azure AI:
```
az extension add -n cognitiveservices
```
Algunos de los comandos de este tutorial usan la herramienta jq, que podría no estar instalada en el sistema. Para obtener las instrucciones de instalación, consulte Descargar jq.
Identifique la siguiente información:
- Su identificador de suscripción de Azure.
- Nombre del recurso de Servicios de Azure AI.
- El grupo de recursos donde se implementa el recurso de Servicios de Azure AI.

Agregar modelos

Para agregar un modelo, primero debe identificar el modelo que desea implementar. Puede consultar los modelos disponibles de la siguiente manera:

Inicie sesión en su suscripción de Azure:
```
az login
```
Si tiene más de una suscripción, seleccione la suscripción donde se encuentra el recurso:
```
az account set --subscription $subscriptionId>
```
Establezca las siguientes variables de entorno con el nombre del recurso de Servicios de Azure AI que planea usar y el grupo de recursos.
```
accountName="<ai-services-resource-name>"
resourceGroupName="<resource-group>"
```
Si aún no tiene una cuenta de Servicios de Azure AI creada, puede crear una como se muestra a continuación:
```
az cognitiveservices account create -n $accountName -g $resourceGroupName
```

Veamos primero qué modelos están disponibles y con qué SKU. El siguiente comando muestra todas las definiciones de modelo disponibles:

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

Las salidas tienen el siguiente aspecto:

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

Identifique el modelo que quiere implementar. Necesita las propiedades name, format, version y sku. La capacidad también puede ser necesaria en función del tipo de implementación.

Sugerencia

Observe que no todos los modelos están disponibles en todos los SKU.

Agregue la implementación de modelo al recurso. En el siguiente ejemplo se agrega 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

El modelo está listo para consumirse.

Puede implementar el mismo modelo varias veces si es necesario siempre que esté bajo un nombre de implementación diferente. Esta funcionalidad puede ser útil en caso de que quiera probar configuraciones diferentes para un modelo determinado, incluida la seguridad del contenido.

Administración de implementaciones

Puede ver todas las implementaciones disponibles con la CLI:

Ejecute el comando siguiente para ver todas las implementaciones activas:

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

Puede ver los detalles de una implementación determinada:

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

Puede eliminar una implementación determinada de la siguiente manera:

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

Uso del modelo

Los modelos implementados en la inferencia del modelo de Azure AI se pueden consumir mediante el punto de conexión de la inferencia del modelo de Azure AI para el recurso. Al construir la solicitud, indique el parámetro model e inserte el nombre de la implementación de modelo que ha creado. Puede obtener mediante programación el URI del punto de conexión de la inferencia mediante el siguiente código:

Punto de conexión de inferencia

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

Para realizar solicitudes al punto de conexión de la inferencia del modelo de Azure AI, anexe la ruta models, por ejemplo, https://<resource>.services.ai.azure.com/models. Puede ver la referencia de API para el punto de conexión en la página de referencia de API de la inferencia del modelo de Azure AI.

Claves de la inferencia

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

Importante

En este artículo, aprenderá a crear los recursos necesarios para usar la inferencia del modelo de Azure AI y a consumir modelos insignia del catálogo de modelos de Azure AI.

Requisitos previos

Para completar este artículo, necesitará lo siguiente:

Suscripción a Azure. Si usa Modelos de GitHub, puede actualizar la experiencia y crear una suscripción de Azure en el proceso. Lea Actualización de modelos de GitHub a la inferencia de modelos de Azure AI si es su caso.

Instale la CLI de Azure.
Identifique la siguiente información:
- Su identificador de suscripción de Azure.

Acerca de este tutorial

El ejemplo de este artículo se basa en los ejemplos de código incluidos en el repositorio Azure-Samples/azureai-model-inference-bicep. Para ejecutar los comandos localmente sin tener que copiar o pegar contenido de archivo, use los siguientes comandos para clonar el repositorio y vaya a la carpeta del lenguaje de codificación:

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

Los archivos de este ejemplo están en:

cd azureai-model-inference-bicep/infra

Descripción de los recursos

El tutorial le ayuda a crear:

Un recurso de Servicios de Azure AI.
Una implementación de modelo en la SKU estándar global para cada uno de los modelos que admiten el pago por uso.
(Opcionalmente) Un proyecto y un centro de Azure AI.
(Opcionalmente) Una conexión entre el centro y los modelos de Servicios de Azure AI.

Está usando los siguientes recursos para crear esos recursos:

Use la plantilla modules/ai-services-template.bicep para describir el recurso de Servicios de Azure AI:

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

Use la plantilla modules/ai-services-deployment-template.bicep para describir las implementaciones 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
  }
}

Para mayor comodidad, definimos el modelo que queremos tener disponible en el servicio mediante un archivo JSON. El archivo infra/models.json contiene una lista de objetos JSON con las claves name, version, provider y sku, que define los modelos que la implementación aprovisionará. Dado que los modelos admiten el pago por uso, agregar implementaciones de modelos no incurre en costos adicionales. Modifique el archivo quitando o agregando las entradas del modelo que desea que estén disponibles. En el ejemplo siguiente se muestran solo las 7 primeras líneas del archivo JSON:

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

Si tiene previsto usar proyectos (recomendado), necesita las plantillas para crear un proyecto, un centro y una conexión al recurso de Servicios de Azure AI:

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

Creación de los recursos

En la consola, siga estos pasos:

Defina la implementación 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

Inicio de sesión en Azure:
```
az login
```
Asegúrese de que está en la suscripción correcta:
```
az account set --subscription "<subscription-id>"
```

Ejecute la implementación:

RESOURCE_GROUP="<resource-group-name>"

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

Si desea implementar solo el recurso de Servicios de Azure AI y las implementaciones de modelo, use el siguiente archivo de implementación:

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

Ejecute la implementación:

RESOURCE_GROUP="<resource-group-name>"

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

La plantilla genera el punto de conexión de inferencia del modelo de Azure AI que puede usar para consumir cualquiera de las implementaciones de modelo que ha creado.

Pasos siguientes

Desarrollo de aplicaciones mediante el servicio de inferencia del modelo de Azure AI en servicios de Azure AI

Compartir a través de

Creación y configuración de todos los recursos para la inferencia de modelos de Azure AI

Requisitos previos

Creación de los recursos

Requisitos previos

Agregar modelos

Administración de implementaciones

Uso del modelo

Requisitos previos

Acerca de este tutorial

Descripción de los recursos

Creación de los recursos

Pasos siguientes

Comentarios

Recursos adicionales