Inicio rápido: Usar Bicep para crear y publicar una definición de aplicación administrada de Azure
Este inicio rápido describe cómo traer su propio almacenamiento para crear y publicar una definición de aplicación administrada de Azure en el catálogo de servicios. La definición del catálogo de servicios está disponible para los miembros de su organización.
Para crear y publicar una definición de aplicación administrada en el catálogo de servicios, deberá realizar las siguientes tareas:
- Usar Bicep para desarrollar la plantilla y convertirla en una plantilla de Azure Resource Manager (plantilla de ARM). La plantilla define los recursos de Azure implementados por la aplicación administrada.
- Utilice el comando Bicep
buildpara convertir Bicep en JSON. Una vez convertido el archivo en JSON, se recomienda comprobar la precisión del código. - Defina los elementos de la interfaz de usuario del portal cuando implemente la aplicación administrada.
- Cree un paquete .zip que contenga los archivos de JSON necesarios. El archivo de paquete .zip tiene un límite de 120 MB para las definiciones de aplicación administrada de un catálogo de servicios.
- Implemente la definición de aplicación administrada para que esté disponible en el catálogo de servicios.
Si la definición de aplicación administrada tiene más de 120 MB o si desea usar su propia cuenta de almacenamiento por motivos de cumplimiento de la organización, vaya a Inicio rápido: traiga su propio almacenamiento para crear y publicar una definición de aplicación administrada de Azure.
También puede utilizar Bicep para implementar una definición de aplicación administrada del catálogo de servicios. Para más información, vaya a Inicio rápido: Usar Bicep para implementar una definición de aplicación administrada por Azure.
Requisitos previos
Para completar las tareas de este artículo, necesitará lo siguiente:
- Una cuenta de Azure con una suscripción activa y permisos para recursos de Microsoft Entra, como usuarios, grupos o entidades de servicio. Antes de comenzar, si no tiene una cuenta, cree una gratuita.
- Visual Studio Code con la extensión Herramientas de Azure Resource Manager más reciente. En el caso de los archivos de Bicep, instale la extensión de Bicep para Visual Studio Code.
- Instale la versión más reciente de Azure PowerShell o la CLI de Azure.
Creación de un archivo de Bicep
Todas las definiciones de aplicaciones administradas incluyen un archivo denominado mainTemplate.json. La plantilla define los recursos de Azure que se van a implementar, y no difiere de una plantilla de ARM normal. Puede desarrollar la plantilla mediante Bicep y, a continuación, convertir el archivo de Bicep en JSON.
Abra Visual Studio Code, cree un archivo con el nombre mainTemplate.bicep (se distingue entre mayúsculas y minúsculas) y guárdelo.
Agregue el código de Bicep siguiente y guarde el archivo. Define los recursos de la aplicación administrada para implementar un plan de App Service, App Service y una cuenta de almacenamiento.
param location string = resourceGroup().location
@description('App Service plan name.')
@maxLength(40)
param appServicePlanName string
@description('App Service name prefix.')
@maxLength(47)
param appServiceNamePrefix string
@description('Storage account name prefix.')
@maxLength(11)
param storageAccountNamePrefix string
@description('Storage account type allowed values')
@allowed([
'Premium_LRS'
'Standard_LRS'
'Standard_GRS'
])
param storageAccountType string
var appServicePlanSku = 'F1'
var appServicePlanCapacity = 1
var appServiceName = '${appServiceNamePrefix}${uniqueString(resourceGroup().id)}'
var storageAccountName = '${storageAccountNamePrefix}${uniqueString(resourceGroup().id)}'
var appServiceStorageConnectionString = 'DefaultEndpointsProtocol=https;AccountName=${storageAccount.name};EndpointSuffix=${environment().suffixes.storage};Key=${storageAccount.listKeys().keys[0].value}'
resource appServicePlan 'Microsoft.Web/serverfarms@2022-03-01' = {
name: appServicePlanName
location: location
sku: {
name: appServicePlanSku
capacity: appServicePlanCapacity
}
}
resource appServiceApp 'Microsoft.Web/sites@2022-03-01' = {
name: appServiceName
location: location
properties: {
serverFarmId: appServicePlan.id
httpsOnly: true
siteConfig: {
appSettings: [
{
name: 'AppServiceStorageConnectionString'
value: appServiceStorageConnectionString
}
]
}
}
}
resource storageAccount 'Microsoft.Storage/storageAccounts@2022-09-01' = {
name: storageAccountName
location: location
sku: {
name: storageAccountType
}
kind: 'StorageV2'
properties: {
accessTier: 'Hot'
}
}
output appServicePlan string = appServicePlan.name
output appServiceApp string = appServiceApp.properties.defaultHostName
output storageAccount string = storageAccount.properties.primaryEndpoints.blob
Conversión de Bicep en JSON
Use PowerShell o la CLI de Azure para compilar el archivo mainTemplate.json . Vaya al directorio donde guardó el archivo Bicep y ejecute el comando build.
bicep build mainTemplate.bicep
Para más información, vaya a Compilación de Bicep.
Después de convertir el archivo Bicep en JSON, el archivo mainTemplate.json debe coincidir con el ejemplo siguiente. Puede tener valores diferentes en las propiedades de metadata para version y templateHash.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"metadata": {
"_generator": {
"name": "bicep",
"version": "0.17.1.54307",
"templateHash": "1234567891234567890"
}
},
"parameters": {
"location": {
"type": "string",
"defaultValue": "[resourceGroup().location]"
},
"appServicePlanName": {
"type": "string",
"maxLength": 40,
"metadata": {
"description": "App Service plan name."
}
},
"appServiceNamePrefix": {
"type": "string",
"maxLength": 47,
"metadata": {
"description": "App Service name prefix."
}
},
"storageAccountNamePrefix": {
"type": "string",
"maxLength": 11,
"metadata": {
"description": "Storage account name prefix."
}
},
"storageAccountType": {
"type": "string",
"allowedValues": [
"Premium_LRS",
"Standard_LRS",
"Standard_GRS"
],
"metadata": {
"description": "Storage account type allowed values"
}
}
},
"variables": {
"appServicePlanSku": "F1",
"appServicePlanCapacity": 1,
"appServiceName": "[format('{0}{1}', parameters('appServiceNamePrefix'), uniqueString(resourceGroup().id))]",
"storageAccountName": "[format('{0}{1}', parameters('storageAccountNamePrefix'), uniqueString(resourceGroup().id))]"
},
"resources": [
{
"type": "Microsoft.Web/serverfarms",
"apiVersion": "2022-03-01",
"name": "[parameters('appServicePlanName')]",
"location": "[parameters('location')]",
"sku": {
"name": "[variables('appServicePlanSku')]",
"capacity": "[variables('appServicePlanCapacity')]"
}
},
{
"type": "Microsoft.Web/sites",
"apiVersion": "2022-03-01",
"name": "[variables('appServiceName')]",
"location": "[parameters('location')]",
"properties": {
"serverFarmId": "[resourceId('Microsoft.Web/serverfarms', parameters('appServicePlanName'))]",
"httpsOnly": true,
"siteConfig": {
"appSettings": [
{
"name": "AppServiceStorageConnectionString",
"value": "[format('DefaultEndpointsProtocol=https;AccountName={0};EndpointSuffix={1};Key={2}', variables('storageAccountName'), environment().suffixes.storage, listKeys(resourceId('Microsoft.Storage/storageAccounts', variables('storageAccountName')), '2022-09-01').keys[0].value)]"
}
]
}
},
"dependsOn": [
"[resourceId('Microsoft.Web/serverfarms', parameters('appServicePlanName'))]",
"[resourceId('Microsoft.Storage/storageAccounts', variables('storageAccountName'))]"
]
},
{
"type": "Microsoft.Storage/storageAccounts",
"apiVersion": "2022-09-01",
"name": "[variables('storageAccountName')]",
"location": "[parameters('location')]",
"sku": {
"name": "[parameters('storageAccountType')]"
},
"kind": "StorageV2",
"properties": {
"accessTier": "Hot"
}
}
],
"outputs": {
"appServicePlan": {
"type": "string",
"value": "[parameters('appServicePlanName')]"
},
"appServiceApp": {
"type": "string",
"value": "[reference(resourceId('Microsoft.Web/sites', variables('appServiceName')), '2022-03-01').defaultHostName]"
},
"storageAccount": {
"type": "string",
"value": "[reference(resourceId('Microsoft.Storage/storageAccounts', variables('storageAccountName')), '2022-09-01').primaryEndpoints.blob]"
}
}
}
Defina su experiencia del portal
Como publicador, define la experiencia del portal para crear la aplicación administrada. El archivo createUiDefinition.json genera la interfaz de usuario del portal. Defina cómo los usuarios proporcionan la entrada para cada parámetro mediante elementos de control, como las listas desplegables y los cuadros de texto.
En este ejemplo, la interfaz de usuario le pide que escriba el prefijo de nombre de App Service, el nombre del plan de App Service, el prefijo de la cuenta de almacenamiento y el tipo de cuenta de almacenamiento. Durante la implementación, las variables de mainTemplate.json usarán la función uniqueString para anexar una cadena de 13 caracteres a los prefijos de nombre para que los nombres sean únicos globalmente en Azure.
Abra Visual Studio Code, cree un archivo con el nombre createUiDefinition.json (se distingue entre mayúsculas y minúsculas) y guárdelo.
Agregue el siguiente código JSON y guárdelo.
{
"$schema": "https://schema.management.azure.com/schemas/0.1.2-preview/CreateUIDefinition.MultiVm.json#",
"handler": "Microsoft.Azure.CreateUIDef",
"version": "0.1.2-preview",
"parameters": {
"basics": [
{}
],
"steps": [
{
"name": "webAppSettings",
"label": "Web App settings",
"subLabel": {
"preValidation": "Configure the web app settings",
"postValidation": "Completed"
},
"elements": [
{
"name": "appServicePlanName",
"type": "Microsoft.Common.TextBox",
"label": "App Service plan name",
"placeholder": "App Service plan name",
"defaultValue": "",
"toolTip": "Use alphanumeric characters or hyphens with a maximum of 40 characters.",
"constraints": {
"required": true,
"regex": "^[a-z0-9A-Z-]{1,40}$",
"validationMessage": "Only alphanumeric characters or hyphens are allowed, with a maximum of 40 characters."
},
"visible": true
},
{
"name": "appServiceName",
"type": "Microsoft.Common.TextBox",
"label": "App Service name prefix",
"placeholder": "App Service name prefix",
"defaultValue": "",
"toolTip": "Use alphanumeric characters or hyphens with minimum of 2 characters and maximum of 47 characters.",
"constraints": {
"required": true,
"regex": "^[a-z0-9A-Z-]{2,47}$",
"validationMessage": "Only alphanumeric characters or hyphens are allowed, with a minimum of 2 characters and maximum of 47 characters."
},
"visible": true
}
]
},
{
"name": "storageConfig",
"label": "Storage settings",
"subLabel": {
"preValidation": "Configure the storage settings",
"postValidation": "Completed"
},
"elements": [
{
"name": "storageAccounts",
"type": "Microsoft.Storage.MultiStorageAccountCombo",
"label": {
"prefix": "Storage account name prefix",
"type": "Storage account type"
},
"toolTip": {
"prefix": "Enter maximum of 11 lowercase letters or numbers.",
"type": "Available choices are Standard_LRS, Standard_GRS, and Premium_LRS."
},
"defaultValue": {
"type": "Standard_LRS"
},
"constraints": {
"allowedTypes": [
"Premium_LRS",
"Standard_LRS",
"Standard_GRS"
]
},
"visible": true
}
]
}
],
"outputs": {
"location": "[location()]",
"appServicePlanName": "[steps('webAppSettings').appServicePlanName]",
"appServiceNamePrefix": "[steps('webAppSettings').appServiceName]",
"storageAccountNamePrefix": "[steps('storageConfig').storageAccounts.prefix]",
"storageAccountType": "[steps('storageConfig').storageAccounts.type]"
}
}
}
Para más información, vaya a Introducción a CreateUiDefinition.
Empaquetado de los archivos
Agregue los dos archivos a un paquete de archivo denominado app.zip. Los dos archivos tienen que estar en el nivel raíz del archivo .zip. Si los archivos estuvieran en una carpeta, cuando cree la definición de la aplicación administrada, recibirá un error indicando que los archivos necesarios no están presentes.
Cargue app.zip en una cuenta de almacenamiento de Azure para que pueda usarla al implementar la definición de la aplicación administrada. El nombre de la cuenta de almacenamiento debe ser único globalmente en Azure y su longitud debe ser de entre 3 y 24 caracteres (solo letras en minúsculas y números). En el comando, reemplace el marcador de posición <demostorageaccount>, incluyendo los corchetes angulares (<>), por el nombre de la cuenta de almacenamiento único.
En Visual Studio Code, abra un nuevo terminal de PowerShell e inicie sesión en su suscripción de Azure.
Connect-AzAccount
Este comando abrirá el explorador predeterminado y le solicitará iniciar sesión en Azure. Para obtener más información, vaya a Inicio de sesión con Azure PowerShell.
Después de conectarse, ejecute los siguientes comandos.
New-AzResourceGroup -Name packageStorageRG -Location westus3
$storageAccount = New-AzStorageAccount `
-ResourceGroupName packageStorageRG `
-Name "<demostorageaccount>" `
-Location westus3 `
-SkuName Standard_LRS `
-Kind StorageV2 `
-AllowBlobPublicAccess $true
$ctx = $storageAccount.Context
New-AzStorageContainer -Name appcontainer -Context $ctx -Permission blob
Set-AzStorageBlobContent `
-File "app.zip" `
-Container appcontainer `
-Blob "app.zip" `
-Context $ctx
Use el siguiente comando para almacenar el URI del archivo de paquete en una variable denominada packageuri. Usará el valor de variable al implementar la definición de aplicación administrada.
$packageuri=(Get-AzStorageBlob -Container appcontainer -Blob app.zip -Context $ctx).ICloudBlob.StorageUri.PrimaryUri.AbsoluteUri
Creación de la definición de aplicación administrada
En esta sección, obtiene información de identidad de Microsoft Entra ID, crea un grupo de recursos e implementa la definición de aplicación administrada.
Obtención del identificador de grupo y el identificador de definición de roles
El siguiente paso consiste en seleccionar un usuario, grupo de seguridad o aplicación para administrar los recursos para el cliente. Esta identidad tiene permisos en el grupo de recursos administrado según el rol asignado. El rol puede ser cualquier rol integrado en Azure, como Propietario o Colaborador.
En este ejemplo se usa un grupo de seguridad, y la cuenta de Microsoft Entra deberá ser miembro del grupo. Para obtener el identificador de objeto del grupo, reemplace el marcador de posición <managedAppDemo>, incluyendo los corchetes angulares (<>), por el nombre del grupo. Usará el valor de variable al implementar la definición de aplicación administrada.
Para crear un nuevo grupo de Microsoft Entra, vaya a Administración de grupos y pertenencia a grupos de Microsoft Entra.
$principalid=(Get-AzADGroup -DisplayName <managedAppDemo>).Id
A continuación, obtenga el identificador de definición de rol para el rol integrado de Azure que desee para conceder acceso al usuario, grupo o aplicación. Usará el valor de variable al implementar la definición de aplicación administrada.
$roleid=(Get-AzRoleDefinition -Name Owner).Id
Creación de la plantilla de implementación de definición
Use un archivo de Bicep para implementar la definición de aplicación administrada en el catálogo de servicios.
Abra Visual Studio Code, cree un archivo llamado deployDefinition.bicep y guárdelo.
Agregue el código de Bicep siguiente y guarde el archivo.
param location string = resourceGroup().location
@description('Name of the managed application definition.')
param managedApplicationDefinitionName string
@description('The URI of the .zip package file.')
param packageFileUri string
@description('Publishers Principal ID that needs permissions to manage resources in the managed resource group.')
param principalId string
@description('Role ID for permissions to the managed resource group.')
param roleId string
var definitionLockLevel = 'ReadOnly'
var definitionDisplayName = 'Sample Bicep managed application'
var definitionDescription = 'Sample Bicep managed application that deploys web resources'
resource managedApplicationDefinition 'Microsoft.Solutions/applicationDefinitions@2021-07-01' = {
name: managedApplicationDefinitionName
location: location
properties: {
lockLevel: definitionLockLevel
description: definitionDescription
displayName: definitionDisplayName
packageFileUri: packageFileUri
authorizations: [
{
principalId: principalId
roleDefinitionId: roleId
}
]
}
}
Para obtener más información sobre las propiedades de plantilla, vaya a Microsoft.Solutions/applicationDefinitions.
El lockLevel del grupo de recursos administrados impedirá que el cliente realice operaciones no deseadas en este grupo de recursos. Actualmente, ReadOnly es el único nivel de bloqueo admitido. ReadOnly especifica que el cliente solo puede leer los recursos presentes en el grupo de recursos administrado. Las identidades del publicador a las que se concede acceso al grupo de recursos administrados están exentas del nivel de bloqueo.
Creación del archivo de parámetros
La plantilla de implementación de la definición de aplicación administrada necesita entradas para varios parámetros. El comando de implementación le pedirá los valores o podrá crear un archivo de parámetros para los valores. En este ejemplo, se usa un archivo de parámetros para pasar los valores de parámetro al comando de implementación.
En Visual Studio Code, cree un archivo denominado deployDefinition.parameters.json y guárdelo.
Agregue lo siguiente al archivo de parámetros y guárdelo. A continuación, reemplace <placeholder values>, incluyendo los corchetes angulares (<>), por sus valores.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentParameters.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"managedApplicationDefinitionName": {
"value": "sampleBicepManagedApplication"
},
"packageFileUri": {
"value": "<placeholder for the packageFileUri>"
},
"principalId": {
"value": "<placeholder for principalid value>"
},
"roleId": {
"value": "<placeholder for roleid value>"
}
}
}
En la tabla siguiente se describen los valores de parámetro de la definición de aplicación administrada.
| Parámetro | Valor |
|---|---|
managedApplicationDefinitionName |
Nombre de la definición de aplicación administrada. En este ejemplo, use sampleBicepManagedApplication. |
packageFileUri |
Escriba el URI en el archivo de paquete .zip. Use el valor de la variable packageuri. El formato es https://yourStorageAccountName.blob.core.windows.net/appcontainer/app.zip. |
principalId |
Identificador de entidad de seguridad de publicadores que necesita permisos para administrar recursos en el grupo de recursos administrados. Use el valor de la variable principalid. |
roleId |
Id. de rol para los permisos para el grupo de recursos administrados. Por ejemplo: Propietario, Colaborador o Lector. Use el valor de la variable roleid. |
Para obtener los valores de la variable:
- Azure PowerShell: en PowerShell, escriba
$variableNamepara mostrar el valor de una variable. - CLI de Azure: en Bash, escriba
echo $variableNamepara mostrar el valor de una variable.
Implementación de la definición
Al implementar la definición de la aplicación administrada, estará disponible en el catálogo de servicios. Este proceso no implementará los recursos de la aplicación administrada.
Cree un grupo de recursos denominado bicepDefinitionRG e implemente la definición de aplicación administrada.
New-AzResourceGroup -Name bicepDefinitionRG -Location westus3
New-AzResourceGroupDeployment `
-ResourceGroupName bicepDefinitionRG `
-TemplateFile deployDefinition.bicep `
-TemplateParameterFile deployDefinition.parameters.json
Verificación de los resultados
Ejecute el siguiente comando para comprobar que la definición se publica en el catálogo de servicios.
Get-AzManagedApplicationDefinition -ResourceGroupName bicepDefinitionRG
Get-AzManagedApplicationDefinition enumera todas las definiciones disponibles del grupo de recursos especificado, como sampleBicepManagedApplication.
Asegurarse de que los usuarios pueden acceder a la definición
Tiene acceso a la definición de la aplicación administrada, pero desea asegurarse de que otros usuarios de su organización puedan acceder a ella. Concédales al menos el rol de lector en la definición. Puede haber heredado este nivel de acceso de la suscripción o del grupo de recursos. Para comprobar quién tiene acceso a la definición y agregar usuarios o grupos, vaya a Asignación de roles de Azure mediante Azure Portal.
Limpieza de recursos
Si va a implementar la definición, continúe con la sección Pasos siguientes que se vincula al artículo para implementar la definición con Bicep.
Si ha terminado con la definición de la aplicación administrada, puede eliminar los grupos de recursos creados denominados packageStorageRG y bicepDefinitionRG.
El comando le pide que confirme que quiere quitar el grupo de recursos.
Remove-AzResourceGroup -Name packageStorageRG
Remove-AzResourceGroup -Name bicepDefinitionRG
Pasos siguientes
Ha publicado la definición de aplicación administrada. El siguiente paso es aprender a implementar una instancia de esa definición.