Avvio rapido: Creare e pubblicare una definizione di applicazione gestita

Questo argomento di avvio rapido fornisce un'introduzione all'uso delle applicazioni gestite di Azure. È possibile creare e pubblicare un'applicazione gestita destinata ai membri dell'organizzazione.

Per pubblicare un'applicazione gestita per il catalogo di servizi, è necessario:

  • Creare un modello di Azure Resource Manager (modello ARM) che definisce le risorse da distribuire con l'applicazione gestita.
  • Definire gli elementi dell'interfaccia utente per il portale quando si distribuisce l'applicazione gestita.
  • Creare un pacchetto con estensione zip contenente i file modello necessari.
  • Decidere quali utenti, gruppi o applicazioni devono accedere al gruppo di risorse nella sottoscrizione dell'utente.
  • Creare la definizione di applicazione gestita che punta al pacchetto con estensione zip e richiede l'accesso per l'identità.

Nota

I file Bicep non possono essere usati in un'applicazione gestita. È necessario convertire un file Bicep in JSON del modello arm con il comando di compilazione Bicep.

Creare il modello di Azure Resource Manager

Ogni definizione di applicazione gestita include un file denominato mainTemplate.json, in cui si definiscono le risorse di Azure da distribuire. Il modello non è diverso da un modello standard di Resource Manager.

Creare un file denominato mainTemplate.json. Per il nome è rilevante la distinzione tra maiuscole e minuscole.

Aggiungere il codice JSON seguente e salvare il file. Definisce i parametri per la creazione di un account di archiviazione e specifica le proprietà per l'account di archiviazione.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "storageAccountNamePrefix": {
      "type": "string"
    },
    "storageAccountType": {
      "type": "string"
    },
    "location": {
      "type": "string",
      "defaultValue": "[resourceGroup().location]"
    }
  },
  "variables": {
    "storageAccountName": "[concat(parameters('storageAccountNamePrefix'), uniqueString(resourceGroup().id))]"
  },
  "resources": [
    {
      "type": "Microsoft.Storage/storageAccounts",
      "apiVersion": "2021-09-01",
      "name": "[variables('storageAccountName')]",
      "location": "[parameters('location')]",
      "sku": {
        "name": "[parameters('storageAccountType')]"
      },
      "kind": "StorageV2",
      "properties": {}
    }
  ],
  "outputs": {
    "storageEndpoint": {
      "type": "string",
      "value": "[reference(resourceId('Microsoft.Storage/storageAccounts/', variables('storageAccountName')), '2021-09-01').primaryEndpoints.blob]"
    }
  }
}

Definire l'esperienza di creazione

Un editore definisce l'esperienza del portale per la creazione dell'applicazione gestita. Il file createUiDefinition.json genera l'interfaccia 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, caselle di testo e caselle per password.

Creare un file denominato createUiDefinition.json. Per il nome viene fatta distinzione tra maiuscole e minuscole.

Aggiungere il codice JSON di base seguente e salvare il file.

{
  "$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": "storageConfig",
        "label": "Storage settings",
        "subLabel": {
          "preValidation": "Configure the infrastructure settings",
          "postValidation": "Done"
        },
        "bladeTitle": "Storage settings",
        "elements": [
          {
            "name": "storageAccounts",
            "type": "Microsoft.Storage.MultiStorageAccountCombo",
            "label": {
              "prefix": "Storage account name prefix",
              "type": "Storage account type"
            },
            "defaultValue": {
              "type": "Standard_LRS"
            },
            "constraints": {
              "allowedTypes": [
                "Premium_LRS",
                "Standard_LRS",
                "Standard_GRS"
              ]
            }
          }
        ]
      }
    ],
    "outputs": {
      "storageAccountNamePrefix": "[steps('storageConfig').storageAccounts.prefix]",
      "storageAccountType": "[steps('storageConfig').storageAccounts.type]",
      "location": "[location()]"
    }
  }
}

Per altre informazioni, vedere Introduzione a CreateUiDefinition.

Creare il pacchetto dei file

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

Caricare il pacchetto in una posizione accessibile da dove può essere usato. È necessario specificare un nome univoco per l'account di archiviazione.

New-AzResourceGroup -Name storageGroup -Location eastus

$storageAccount = New-AzStorageAccount `
  -ResourceGroupName storageGroup `
  -Name "mystorageaccount" `
  -Location eastus `
  -SkuName Standard_LRS `
  -Kind StorageV2

$ctx = $storageAccount.Context

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

Set-AzStorageBlobContent `
  -File "D:\myapplications\app.zip" `
  -Container appcontainer `
  -Blob "app.zip" `
  -Context $ctx

Creare la definizione di applicazione gestita

Creare un'applicazione o un gruppo di utenti Azure Active Directory

Il passaggio successivo consiste nel selezionare un gruppo di utenti, un utente o un'applicazione per gestire le risorse per il cliente. Questa identità ha autorizzazioni per il gruppo di risorse gestito in base al ruolo assegnato. Il ruolo può essere qualsiasi ruolo predefinito di Azure, ad esempio Proprietario o Collaboratore. Per creare un nuovo gruppo di utenti di Active Directory, vedere Creare un gruppo e aggiungere membri in Azure Active Directory.

È necessario munirsi dell'ID oggetto del gruppo di utenti da usare per la gestione delle risorse.

$groupID=(Get-AzADGroup -DisplayName mygroup).Id

Ottenere l'ID di definizione del ruolo

Ora è necessario l'ID di definizione del ruolo predefinito di Azure a cui concedere l'accesso all'utente, al gruppo utenti o all'applicazione. In genere si usa il ruolo Proprietario, Collaboratore o Lettore. Il comando seguente illustra come ottenere l'ID di definizione per il ruolo Proprietario:

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

Creare la definizione di applicazione gestita

Se non è già disponibile un gruppo di risorse per archiviare la definizione di applicazione gestita, crearne uno ora:

New-AzResourceGroup -Name appDefinitionGroup -Location westcentralus

Creare a questo punto la definizione di applicazione gestita.

$blob = Get-AzStorageBlob -Container appcontainer -Blob app.zip -Context $ctx

New-AzManagedApplicationDefinition `
  -Name "ManagedStorage" `
  -Location "westcentralus" `
  -ResourceGroupName appDefinitionGroup `
  -LockLevel ReadOnly `
  -DisplayName "Managed Storage Account" `
  -Description "Managed Azure Storage Account" `
  -Authorization "${groupID}:$roleid" `
  -PackageFileUri $blob.ICloudBlob.StorageUri.PrimaryUri.AbsoluteUri

Al completamento del comando, è disponibile una definizione dell'applicazione gestita nel gruppo di risorse.

Ecco alcuni parametri usati nell'esempio precedente:

  • Gruppo di risorse: nome del gruppo di risorse in cui viene creata la definizione di applicazione gestita.

  • Livello di blocco: tipo di blocco inserito nel gruppo di risorse gestito. Impedisce al cliente di eseguire operazioni indesiderate su questo gruppo di risorse. ReadOnly è attualmente il solo livello di blocco supportato. Quando ReadOnly è specificato, il cliente può solo leggere le risorse presenti nel gruppo di risorse gestito. Le identità degli autori a cui è concesso l'accesso al gruppo di risorse gestito sono esenti dal blocco.

  • authorizations: indica l'ID dell'entità di sicurezza e l'ID di definizione del ruolo usati per concedere l'autorizzazione al gruppo di risorse gestito.

    • Azure PowerShell: "${groupid}:$roleid" oppure è possibile usare parentesi graffe per ogni variabile "${groupid}:${roleid}". Usare una virgola per separare più valori: "${groupid1}:$roleid1", "${groupid2}:$roleid2".
    • Interfaccia della riga di comando di Azure: "$groupid:$roleid" oppure è possibile usare parentesi graffe come illustrato in PowerShell. Usare uno spazio per separare più valori: "$groupid1:$roleid1" "$groupid2:$roleid2".
  • URI del file del pacchetto: la posizione di un pacchetto con estensione zip che include i file necessari.

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

In alternativa, è possibile scegliere di archiviare la definizione dell'applicazione gestita all'interno di un account di archiviazione fornito dall'utente durante la creazione in modo che il percorso e l'accesso possano essere completamente gestiti dall'utente per le esigenze normative.

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.

Selezionare l'account di archiviazione

È necessario creare un account di archiviazione per contenere la definizione di applicazione gestita per l'uso con il catalogo di servizi.

Copiare l'ID risorsa dell'account di archiviazione. Verrà usato più avanti durante la distribuzione della definizione.

Impostare l'assegnazione di ruolo per "Provider di risorse di Appliance" nell'account di archiviazione

Prima che la definizione dell'applicazione gestita possa essere distribuita nell'account di archiviazione, assegnare il ruolo Collaboratore all'utente del provider di risorse appliance nell'ambito dell'account di archiviazione. Questa assegnazione consente ai file di definizione di scrittura dell'identità nel contenitore dell'account di archiviazione.

Per i passaggi dettagliati, vedere Assegnare ruoli di Azure usando l'portale di Azure.

Distribuire la definizione di applicazione gestita con un modello di Resource Manager

Usare il modello di Resource Manager seguente per distribuire l'applicazione gestita compressa come nuova definizione di applicazione gestita nel catalogo di servizi i cui file di definizione vengono archiviati e mantenuti nel proprio account di archiviazione:

{
  "$schema": "http://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "location": {
      "type": "string",
      "defaultValue": "[resourceGroup().location]"
    },
    "applicationName": {
      "type": "string",
      "metadata": {
        "description": "Managed Application name"
      }
    },
    "storageAccountType": {
      "type": "string",
      "defaultValue": "Standard_LRS",
      "allowedValues": [
        "Standard_LRS",
        "Standard_GRS",
        "Standard_ZRS",
        "Premium_LRS"
      ],
      "metadata": {
        "description": "Storage Account type"
      }
    },
    "definitionStorageResourceID": {
      "type": "string",
      "metadata": {
        "description": "Storage account resource ID for where you're storing your definition"
      }
    },
    "_artifactsLocation": {
      "type": "string",
      "metadata": {
        "description": "The base URI where artifacts required by this template are located."
      }
    }
  },
  "variables": {
    "lockLevel": "None",
    "description": "Sample Managed application definition",
    "displayName": "Sample Managed application definition",
    "managedApplicationDefinitionName": "[parameters('applicationName')]",
    "packageFileUri": "[parameters('_artifactsLocation')]",
    "defLocation": "[parameters('definitionStorageResourceID')]",
    "managedResourceGroupId": "[concat(subscription().id,'/resourceGroups/', concat(parameters('applicationName'),'_managed'))]",
    "applicationDefinitionResourceId": "[resourceId('Microsoft.Solutions/applicationDefinitions',variables('managedApplicationDefinitionName'))]"
  },
  "resources": [
    {
      "type": "Microsoft.Solutions/applicationDefinitions",
      "apiVersion": "2020-08-21-preview",
      "name": "[variables('managedApplicationDefinitionName')]",
      "location": "[parameters('location')]",
      "properties": {
        "lockLevel": "[variables('lockLevel')]",
        "description": "[variables('description')]",
        "displayName": "[variables('displayName')]",
        "packageFileUri": "[variables('packageFileUri')]",
        "storageAccountId": "[variables('defLocation')]"
      }
    }
  ],
  "outputs": {}
}

Le applicationDefinitions proprietà includono storageAccountId che contiene l'ID dell'account di archiviazione per l'account di archiviazione. È possibile verificare che i file di definizione dell'applicazione vengano salvati nell'account di archiviazione specificato in un contenitore denominato applicationDefinitions.

Nota

Per la sicurezza aggiunta, è possibile creare una definizione di applicazioni gestite 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 visualizzare la definizione nel catalogo di servizi.

Assicurarsi che gli utenti possano visualizzare la 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, vedere Assegnare ruoli di Azure usando il portale di Azure.

Passaggi successivi

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