Condividi tramite

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

  • Articolo

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:

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

La variabile $pkgstorageparms usa lo splatting di PowerShell per migliorare la leggibilità dei valori dei parametri usati nel comando per creare il nuovo account di archiviazione. Lo splatting viene usato in altri comandi di PowerShell che usano più valori di parametro.

Dopo aver creato l'account di archiviazione, aggiungere l'assegnazione di ruolo Collaboratore ai dati dei BLOB di archiviazione all'ambito dell'account di archiviazione. Assegnare l'accesso all'account utente Microsoft Entra. A seconda del livello di accesso in Azure, potrebbero essere necessarie altre autorizzazioni assegnate dall'amministratore. Per altre informazioni, vedere Assegnare un ruolo di Azure per l'accesso ai dati BLOB e Assegnare ruoli di Azure usando il portale di Azure.

Dopo aver aggiunto il ruolo all'account di archiviazione, sono necessari alcuni minuti prima che diventi attivo in Azure. È quindi possibile creare il contesto necessario per creare il contenitore e caricare il file.

$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

Usare il comando seguente per archiviare l'URI del file di pacchetto in una variabile denominata packageuri. Quando si distribuisce la definizione di applicazione gestita, si usa il valore della variabile.

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

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.

Nota

La funzionalità Bring Your Own Storage è supportata solo con le distribuzioni di modelli di Resource Manager o API REST della definizione di applicazione gestita.

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

Dopo aver creato l'account di archiviazione, aggiungere l'assegnazione di ruolo Collaboratore ai dati dei BLOB di archiviazione all'ambito dell'account di archiviazione. Assegnare l'accesso all'account utente Microsoft Entra. L'accesso è necessario per un passaggio successivo del processo.

Dopo aver aggiunto il ruolo all'account di archiviazione, sono necessari alcuni minuti prima che diventi attivo in Azure. È quindi possibile creare il contesto necessario per creare il contenitore e caricare il file.

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

Usare il comando seguente per archiviare l'ID risorsa dell'account di archiviazione in una variabile denominata byosstorageid. Quando si distribuisce la definizione di applicazione gestita, si usa il valore della variabile.

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

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.

È possibile usare le variabili per configurare l'assegnazione di ruolo. Questo esempio usa la variabile $byosstorageid creata nel passaggio precedente e crea la variabile $arpid.

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

New-AzRoleAssignment -ObjectId $arpid -RoleDefinitionName 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

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

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.

Parametro Valore
managedApplicationDefinitionName Nome della definizione di applicazione gestita. Per questo esempio, usare sampleByosManagedApplication.
definitionStorageResourceID ID risorsa per l'account di archiviazione in cui è archiviata la definizione. Usare il valore della variabile byosstorageid.
packageFileUri Immettere l'URI per il file di pacchetto .zip. Usare il valore della variabile packageuri.
principalId ID entità di sicurezza dell'editore che necessita delle autorizzazioni per gestire le risorse nel gruppo di risorse gestite. Usare il valore della variabile principalid.
roleId ID ruolo per le autorizzazioni per il gruppo di risorse gestite. Ad esempio Proprietario, Collaboratore, Lettore. Usare il valore della variabile roleid.

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

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

Nota

Per maggiore sicurezza, è possibile creare una definizione di applicazione gestita e archiviarla in un BLOB dell'account di archiviazione di Azure in cui è abilitata la crittografia. Il contenuto della definizione viene crittografato tramite le opzioni di crittografia dell'account di archiviazione. Solo gli utenti con autorizzazioni per il file possono accedere alla definizione nel catalogo di servizi.

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

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.

Il comando chiede di confermare la rimozione del gruppo di risorse.

Remove-AzResourceGroup -Name packageStorageGroup

Remove-AzResourceGroup -Name byosDefinitionStorageGroup

Remove-AzResourceGroup -Name byosAppDefinitionGroup

Passaggi successivi

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

Avvio rapido: Distribuire un'applicazione gestita del catalogo di servizi