Avvio rapido: Creare e pubblicare una definizione di applicazione gestita di Azure con una risorsa di archiviazione personalizzata (BYOS, Bring Your Own Storage)

Questa guida di avvio rapido fornisce un'introduzione all'uso di una risorsa di archiviazione personalizzata (BYOS, Bring Your Own Storage) per un'applicazione gestita di Azure. Creare e pubblicare una definizione di applicazione gestita nel catalogo di servizi per i membri della propria organizzazione. Quando si usa un account di archiviazione personalizzato, la definizione di applicazione gestita può superare il limite di 120 MB del catalogo di servizi.

Per pubblicare una definizione di applicazione gestita nel catalogo di servizi, seguire questa procedura:

• Creare un modello di Azure Resource Manager (modello di ARM) che definisce le risorse di Azure distribuite dall'applicazione gestita.
• Definire gli elementi dell'interfaccia utente per il portale quando si distribuisce l'applicazione gestita.
• Creare un pacchetto .zip contenente i file JSON necessari.
• Creare un account di archiviazione in cui archiviare la definizione di applicazione gestita.
• Distribuire la definizione di applicazione gestita nel proprio account di archiviazione in modo che sia disponibile nel catalogo dei servizi.

Se la definizione di applicazione gestita è inferiore a 120 MB e non si vuole usare il proprio account di archiviazione, passare a Avvio rapido: Creare e pubblicare una definizione di applicazione gestita di Azure.

È possibile usare Bicep per sviluppare una definizione di applicazione gestita, ma deve essere convertita in un file JSON del modello di ARM prima di poterla pubblicare in Azure. Per altre informazioni, vedere Avvio rapido: Usare Bicep per creare e pubblicare una definizione di applicazione gestita di Azure.

È anche possibile usare Bicep per distribuire una definizione di applicazione gestita dal catalogo di servizi. Per altre informazioni, vedere Avvio rapido: Usare Bicep per distribuire una definizione di applicazione gestita di Azure.

Prerequisiti

Per completare questa guida di avvio rapido sono necessari:

• Un account Azure con una sottoscrizione attiva e le autorizzazioni per le risorse di Microsoft Entra, ad esempio utenti, gruppi o entità servizio. Se non si ha un account Azure, crearne uno gratuito prima di iniziare.
• Visual Studio Code con l'estensione Strumenti di Azure Resource Manager più recente. Per i file Bicep, installare l'estensione Bicep per Visual Studio Code.
• Installare la versione più recente di Azure PowerShell o dell'interfaccia della riga di comando di Azure.

Creare il modello di Resource Manager

Ogni definizione di applicazione gestita include un file denominato mainTemplate.json, Il modello definisce le risorse di Azure da distribuire e non è diverso da un normale modello di ARM.

Aprire Visual Studio Code, creare un file con un nome che fa distinzione tra maiuscole e minuscole mainTemplate.json e salvarlo.

Aggiungere il codice JSON seguente e salvare il file. Definisce le risorse dell'applicazione gestita per distribuire un servizio app, un piano di servizio app e un account di archiviazione.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "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."
      }
    }
  },
  "variables": {
    "appServicePlanSku": "B1",
    "appServicePlanCapacity": 1,
    "appServiceName": "[format('{0}{1}', parameters('appServiceNamePrefix'), uniqueString(resourceGroup().id))]",
    "linuxFxVersion": "DOTNETCORE|8.0"
  },
  "resources": [
    {
      "type": "Microsoft.Web/serverfarms",
      "apiVersion": "2023-01-01",
      "name": "[parameters('appServicePlanName')]",
      "location": "[parameters('location')]",
      "sku": {
        "name": "[variables('appServicePlanSku')]",
        "capacity": "[variables('appServicePlanCapacity')]"
      },
      "kind": "linux",
      "properties": {
        "zoneRedundant": false,
        "reserved": true
      }
    },
    {
      "type": "Microsoft.Web/sites",
      "apiVersion": "2023-01-01",
      "name": "[variables('appServiceName')]",
      "location": "[parameters('location')]",
      "properties": {
        "serverFarmId": "[resourceId('Microsoft.Web/serverfarms', parameters('appServicePlanName'))]",
        "httpsOnly": true,
        "redundancyMode": "None",
        "siteConfig": {
          "linuxFxVersion": "[variables('linuxFxVersion')]",
          "minTlsVersion": "1.2",
          "ftpsState": "Disabled"
        }
      },
      "dependsOn": [
        "[resourceId('Microsoft.Web/serverfarms', parameters('appServicePlanName'))]"
      ]
    }
  ],
  "outputs": {
    "appServicePlan": {
      "type": "string",
      "value": "[parameters('appServicePlanName')]"
    },
    "appServiceApp": {
      "type": "string",
      "value": "[reference(resourceId('Microsoft.Web/sites', variables('appServiceName')), '2023-01-01').defaultHostName]"
    }
  }
}

Definire l'esperienza del portale

Un editore definisce l'esperienza del portale per la creazione dell'applicazione gestita. Il file createUiDefinition.json genera l'interfaccia utente del portale. È possibile definire il modo in cui gli utenti specificheranno l'input per ogni parametro usando elementi di controllo, ad esempio elenchi a discesa e caselle di testo.

In questo esempio, l'interfaccia utente richiede di immettere il prefisso del nome del Servizio app e il nome del piano di servizio app. Durante la distribuzione di mainTemplate.json, le variabili appServiceName usano la funzione uniqueString per aggiungere una stringa di 13 caratteri al prefisso del nome in modo che il nome sia univoco a livello globale in Azure.

Aprire Visual Studio Code, creare un file con un nome che fa distinzione tra maiuscole e minuscole createUiDefinition.json e salvarlo.

Aggiungere il codice JSON seguente al file e salvarlo.

{
  "$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
          }
        ]
      }
    ],
    "outputs": {
      "location": "[location()]",
      "appServicePlanName": "[steps('webAppSettings').appServicePlanName]",
      "appServiceNamePrefix": "[steps('webAppSettings').appServiceName]"
    }
  }
}

Per altre informazioni, vedere Introduzione a CreateUiDefinition.

Creare il pacchetto dei file

Aggiungere i due file a un file di pacchetto denominato app.zip. I due file devono trovarsi al livello radice del file con estensione zip. Se i file si trovano all'interno di una cartella, durante la creazione della definizione di applicazione gestita viene visualizzato un errore che indica che i file necessari non sono presenti.

Caricare app.zip in un account di archiviazione di Azure in modo da poterlo usare quando si distribuisce la definizione di applicazione gestita. Il nome dell'account di archiviazione deve essere univoco a livello globale in Azure, la lunghezza deve essere compresa tra 3 e 24 caratteri e deve contenere solo lettere minuscole e numeri. Nel comando sostituire il segnaposto <pkgstorageaccountname>, incluse le parentesi acute (<>), con il nome dell'account di archiviazione univoco.

New-AzResourceGroup -Name packageStorageGroup -Location westus

$pkgstorageparms = @{
  ResourceGroupName = "packageStorageGroup"
  Name = "<pkgstorageaccountname>"
  Location = "westus"
  SkuName = "Standard_LRS"
  Kind = "StorageV2"
  MinimumTlsVersion = "TLS1_2"
  AllowBlobPublicAccess = $true
  AllowSharedKeyAccess = $false
}

$pkgstorageaccount = New-AzStorageAccount @pkgstorageparms

$pkgstoragecontext = New-AzStorageContext -StorageAccountName $pkgstorageaccount.StorageAccountName -UseConnectedAccount

New-AzStorageContainer -Name appcontainer -Context $pkgstoragecontext -Permission blob

$blobparms = @{
  File = "app.zip"
  Container = "appcontainer"
  Blob = "app.zip"
  Context = $pkgstoragecontext
}

Set-AzStorageBlobContent @blobparms

$packageuri=(Get-AzStorageBlob -Container appcontainer -Blob app.zip -Context $pkgstoragecontext).ICloudBlob.StorageUri.PrimaryUri.AbsoluteUri

az group create --name packageStorageGroup --location westus

az storage account create \
  --name <pkgstorageaccountname> \
  --resource-group packageStorageGroup \
  --location westus \
  --sku Standard_LRS \
  --kind StorageV2 \
  --min-tls-version TLS1_2 \
  --allow-blob-public-access true \
  --allow-shared-key-access false

pkgstgacct=$(az storage account show \
  --resource-group packageStorageGroup \
  --name <pkgstorageaccountname> \
  --query name \
  --output tsv)

az storage container create \
  --account-name $pkgstgacct \
  --name appcontainer \
  --auth-mode login \
  --public-access blob

az storage blob upload \
  --account-name $pkgstgacct \
  --container-name appcontainer \
  --auth-mode login \
  --name "app.zip" \
  --file "app.zip"

packageuri=$(az storage blob url \
  --account-name $pkgstgacct \
  --container-name appcontainer \
  --auth-mode login \
  --name app.zip --output tsv)

Usare la propria risorsa di archiviazione per la definizione di applicazione gestita

È possibile scegliere di archiviare la definizione di applicazione gestita all'interno dell'account di archiviazione personalizzato specificato durante la creazione, in modo che la posizione e l'accesso possano essere gestiti dall'utente per le esigenze normative dell'organizzazione. L'utilizzo dell'account di archiviazione personalizzato consente di superare il limite di 120 MB per una definizione di applicazione gestita del catalogo di servizi.

Creare l'account di archiviazione

Creare l'account di archiviazione per la definizione di applicazione gestita. Il nome dell'account di archiviazione deve essere univoco a livello globale in Azure, la lunghezza deve essere compresa tra 3 e 24 caratteri e deve contenere solo lettere minuscole e numeri.

Questo esempio crea un nuovo gruppo di risorse denominato byosDefinitionStorageGroup. Nel comando sostituire il segnaposto <byosaccountname> incluse le parentesi acute (<>), con il nome dell'account di archiviazione univoco.

New-AzResourceGroup -Name byosDefinitionStorageGroup -Location westus

$byostorageparms = @{
  ResourceGroupName = "byosDefinitionStorageGroup"
  Name = "<byosaccountname>"
  Location = "westus"
  SkuName = "Standard_LRS"
  Kind = "StorageV2"
  MinimumTlsVersion = "TLS1_2"
  AllowBlobPublicAccess = $true
  AllowSharedKeyAccess = $true
}

$byosstorageaccount = New-AzStorageAccount @byostorageparms

$byosstoragecontext = New-AzStorageContext -StorageAccountName $byosstorageaccount.StorageAccountName -UseConnectedAccount

$byosstorageid = (Get-AzStorageAccount -ResourceGroupName $byosstorageaccount.ResourceGroupName -Name $byosstorageaccount.StorageAccountName).Id

az group create --name byosDefinitionStorageGroup --location westus

az storage account create \
  --name <byosaccountname> \
  --resource-group byosDefinitionStorageGroup \
  --location westus \
  --sku Standard_LRS \
  --kind StorageV2 \
  --min-tls-version TLS1_2 \
  --allow-blob-public-access true \
  --allow-shared-key-access true

byosrg=$(az group show --name byosDefinitionStorageGroup --query name --output tsv)

byosstgacct=$(az storage account show --resource-group $byosrg --name <byosaccountname> --query name --output tsv)

byosstorageid=$(az storage account show --resource-group $byosrg --name $byosstgacct --query id --output tsv)

Impostare l'assegnazione di ruolo per l'account di archiviazione

Prima di distribuire la definizione di applicazione gestita nell'account di archiviazione, assegnare il ruolo Collaboratore all'utente del Provider di risorse appliance nell'ambito dell'account di archiviazione. Questa assegnazione consente all'identità di scrivere i file di definizione nel contenitore dell'account di archiviazione.

$arpid = (Get-AzADServicePrincipal -SearchString "Appliance Resource Provider").Id

New-AzRoleAssignment -ObjectId $arpid -RoleDefinitionName Contributor -Scope $byosstorageid

arpid=$(az ad sp list --display-name "Appliance Resource Provider" --query [].id --output tsv)

az role assignment create --assignee $arpid --role "Contributor" --scope $byosstorageid

Il Provider di risorse appliance è un'entità servizio nel tenant di Microsoft Entra. Dal portale di Azure è possibile verificare se è registrata passando a Microsoft Entra ID>Applicazioni aziendali e impostando il filtro di ricerca su Applicazioni Microsoft. Cercare Provider di risorse appliance. Se non viene trovato, registrare il provider di risorse Microsoft.Solutions.

Ottenere l'ID gruppo e l'ID definizione del ruolo

Nel passaggio successivo si selezionerà un gruppo di utenti, un utente o un'applicazione per gestire le risorse per il cliente. Questa identità ha le autorizzazioni per il gruppo di risorse gestite in base al ruolo assegnato. Il ruolo può essere qualsiasi ruolo predefinito di Azure, ad esempio Proprietario o Collaboratore.

Questo esempio usa un gruppo di sicurezza e l'account Microsoft Entra deve essere membro del gruppo. Per ottenere l'ID oggetto del gruppo, sostituire il segnaposto <managedAppDemo> incluse le parentesi acute (<>) con il nome del gruppo. Quando si distribuisce la definizione di applicazione gestita, si usa il valore della variabile.

Per creare un nuovo gruppo di Microsoft Entra, passare a Gestire i gruppi di Microsoft Entra e l'appartenenza a gruppi.

$principalid=(Get-AzADGroup -DisplayName <managedAppDemo>).Id

principalid=$(az ad group show --group <managedAppDemo> --query id --output tsv)

Recuperare quindi l'ID definizione del ruolo predefinito di Azure a cui concedere l'accesso all'utente, al gruppo o all'applicazione. Quando si distribuisce la definizione di applicazione gestita, si usa il valore della variabile.

$roleid=(Get-AzRoleDefinition -Name Owner).Id

roleid=$(az role definition list --name Owner --query [].name --output tsv)

Creare il modello di distribuzione delle definizioni

Usare un file Bicep per distribuire la definizione di applicazione gestita nel catalogo di servizi. Dopo la distribuzione, i file di definizione vengono archiviati nell'account di archiviazione personalizzato.

Aprire Visual Studio Code, creare un file con il nome deployDefinition.bicep e salvarlo.

Aggiungere il codice Bicep seguente e salvare il file.

param location string = resourceGroup().location

@description('Name of the managed application definition.')
param managedApplicationDefinitionName string

@description('Resource ID for the bring your own storage account where the definition is stored.')
param definitionStorageResourceID 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 BYOS managed application'
var definitionDescription = 'Sample BYOS 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
    storageAccountId: definitionStorageResourceID
    authorizations: [
      {
        principalId: principalId
        roleDefinitionId: roleId
      }
    ]
  }
}

Per altre informazioni sulle proprietà del modello, vedere Microsoft.Solutions/applicationDefinitions.

lockLevel nel gruppo di risorse gestite impedisce al cliente di eseguire operazioni indesiderate su questo gruppo di risorse. ReadOnly è attualmente il solo livello di blocco supportato. ReadOnly specifica che il cliente è autorizzato solo alla lettura delle risorse presenti nel gruppo di risorse gestite. Le identità degli editori a cui è concesso l'accesso al gruppo di risorse gestito sono esenti dal livello di blocco.

Creare il file di parametri

Il modello di distribuzione della definizione di applicazione gestita richiede l'input per numerosi parametri. Il comando di distribuzione richiede di immettere i valori oppure è possibile creare un file di parametri per i valori. In questo esempio verrà usato un file di parametri per passare i valori dei parametri al comando di distribuzione.

In Visual Studio Code creare un nuovo file denominato deployDefinition-parameters.bicepparam e salvarlo.

Aggiungere quanto segue al file dei parametri e salvarlo. Sostituire quindi <placeholder values>, incluse le parentesi acute (<>), con i valori.

using './deployDefinition.bicep'

param managedApplicationDefinitionName = 'sampleByosManagedApplication'
param definitionStorageResourceID = '<placeholder for you BYOS storage account ID>'
param packageFileUri = '<placeholder for the packageFileUri>'
param principalId = '<placeholder for principalid value>'
param roleId = '<placeholder for roleid value>'

Nella tabella seguente vengono descritti i valori dei parametri per la definizione di applicazione gestita.

Per ottenere i valori delle variabili:

• Azure PowerShell: in PowerShell digitare $variableName per visualizzare il valore di una variabile.
• Interfaccia della riga di comando di Azure: in Bash digitare echo $variableName per visualizzare il valore di una variabile.

Distribuire la definizione

Con la distribuzione, la definizione di applicazione gestita diventa disponibile nel catalogo di servizi. Questo processo non distribuisce le risorse dell'applicazione gestita.

Creare un gruppo di risorse denominato byosAppDefinitionGroup e distribuire la definizione di applicazione gestita nell'account di archiviazione.

New-AzResourceGroup -Name byosAppDefinitionGroup -Location westus

$deployparms = @{
  ResourceGroupName = "byosAppDefinitionGroup"
  TemplateFile = "deployDefinition.bicep"
  TemplateParameterFile = "deployDefinition-parameters.bicepparam"
  Name = "deployDefinition"
}

New-AzResourceGroupDeployment @deployparms

az group create --name byosAppDefinitionGroup --location westus

az deployment group create \
  --resource-group byosAppDefinitionGroup \
  --template-file deployDefinition.bicep \
  --parameters deployDefinition-parameters.bicepparam \
  --name "deployDefinition"

Verificare l'account di archiviazione dei file di definizione

Durante la distribuzione, la proprietà storageAccountId del modello usa l'ID risorsa dell'account di archiviazione e crea un nuovo contenitore con il nome applicationdefinitions con distinzione maiuscole/minuscole. I file del pacchetto .zip specificato durante la distribuzione vengono archiviati nel nuovo contenitore.

È possibile usare i comandi seguenti per verificare che i file di definizione dell'applicazione gestita vengano salvati nel contenitore dell'account di archiviazione.

Get-AzStorageContainer -Name applicationdefinitions -Context $byosstoragecontext |
Get-AzStorageBlob | Select-Object -Property Name | Format-List

az storage blob list \
  --container-name applicationdefinitions \
  --account-name $byosstgacct \
  --auth-mode login \
  --query "[].{Name:name}"

Aggio della sicurezza dell'account di archiviazione

Dopo aver completato la distribuzione, per migliorare la sicurezza dell'account di archiviazione, disabilitare la proprietà della chiave di accesso condiviso. Quando è stato creato l'account di archiviazione, è stata aggiunta un'assegnazione di ruolo di Collaboratore ai dati dei BLOB che consente di accedere al contenitore e ai BLOB senza usare le chiavi di archiviazione.

Per rivedere e aggiornare le impostazioni della chiave di accesso condiviso dell'account di archiviazione, usare i comandi seguenti:

(Get-AzStorageAccount -ResourceGroupName $byosstorageaccount.ResourceGroupName -Name $byosstorageaccount.StorageAccountName).AllowSharedKeyAccess

Set-AzStorageAccount -ResourceGroupName $byosstorageaccount.ResourceGroupName -Name $byosstorageaccount.StorageAccountName -AllowSharedKeyAccess $false

az storage account show --resource-group $byosrg --name $byosstgacct --query allowSharedKeyAccess --output table

az storage account update --resource-group $byosrg --name $byosstgacct --allow-shared-key-access false

Assicurarsi che gli utenti possano accedere alla definizione

Si ha accesso alla definizione dell'applicazione gestita, ma si vuole assicurarsi che gli altri utenti nell'organizzazione possano accedervi. Concedere loro almeno il ruolo di Lettore per la definizione. Gli utenti potrebbero aver ereditato questo livello di accesso dalla sottoscrizione o dal gruppo di risorse. Per verificare chi può accedere alla definizione e aggiungere utenti o gruppi, passare a Assegnare ruoli di Azure usando il portale di Azure.

Pulire le risorse

Se si intende distribuire la definizione, continuare con la sezione Passaggi successivi che include un collegamento all'articolo per distribuire la definizione.

Se la definizione dell'applicazione gestita non è più necessaria, è possibile eliminare i gruppi di risorse denominati packageStorageGroup, byosDefinitionStorageGroup e byosAppDefinitionGroup.

Remove-AzResourceGroup -Name packageStorageGroup

Remove-AzResourceGroup -Name byosDefinitionStorageGroup

Remove-AzResourceGroup -Name byosAppDefinitionGroup

az group delete --resource-group packageStorageGroup --no-wait

az group delete --resource-group byosDefinitionStorageGroup --no-wait

az group delete --resource-group byosAppDefinitionGroup --no-wait

Passaggi successivi

La definizione di applicazione gestita è stata pubblicata. Ora si vedrà come distribuire un'istanza di tale definizione.