Démarrage rapide : utiliser Bicep pour créer et publier une définition d’application managée Azure

Article
09/22/2024

Ce démarrage rapide vous décrit comment utiliser Bicep pour créer et publier une définition d’application managée Azure dans votre catalogue de services. Les définitions contenues dans votre catalogue de services sont à la disposition des membres de votre organisation.

Pour créer et publier une définition d’application managée dans votre catalogue de services, effectuez les tâches suivantes :

Utilisez Bicep pour développer votre modèle et le convertir en modèle Azure Resource Manager (modèle ARM). Le modèle définit les ressources Azure déployées par l’application managée.
Convertissez Bicep en JSON en tirant parti de la commande Bicep build. Une fois le fichier converti en JSON, vérifiez l’exactitude du code.
Définir les éléments d’interface utilisateur du portail lors du déploiement de l’application managée.
Créez un package .zip qui contient les fichiers JSON nécessaires. Le fichier de package .zip a une limite de 120 Mo pour la définition d’application managée d’un catalogue de services.
Publiez la définition d’application managée pour qu’elle soit disponible dans votre catalogue de services.

Si votre définition d’application managée est supérieure à 120 Mo ou si vous souhaitez utiliser votre propre compte de stockage pour les raisons de conformité de votre organisation, accédez à Démarrage rapide et apportez votre propre stockage pour créer et publier une définition d’application managée Azure.

Vous pouvez également utiliser Bicep pour déployer une définition d’application managée depuis votre catalogue de services. Pour plus d’informations, consultez Démarrage rapide : utiliser Bicep pour déployer une définition d’application managée Azure.

Prérequis

Pour effectuer les tâches mentionnées dans cet article, vous avez besoin des éléments suivants :

Un compte Azure avec un abonnement actif et des autorisations sur des ressources Microsoft Entra comme des utilisateurs, des groupes ou des principaux de service. Si vous n’avez pas de compte, créez-en un gratuitement avant de commencer.
Visual Studio Code avec la dernière version de l’extension Outils Azure Resource Manager Pour les fichiers Bicep, installez l’extension Bicep pour Visual Studio Code.
Installez la version la plus récente d’Azure PowerShell ou Azure CLI.

Créer un fichier Bicep

Chaque définition d’application managée contient un fichier nommé mainTemplate.json. Le modèle définit les ressources Azure à déployer, et n’est pas différent d’un modèle ARM standard. Vous pouvez développer le modèle en utilisant Bicep, puis convertissez le fichier Bicep au format JSON.

Ouvrez Visual Studio Code, créez un fichier avec le nom mainTemplate.bicep (respecte la casse), puis enregistrez-le.

Ajoutez le code Bicep suivant et enregistrez le fichier. Il définit les ressources de l’application managée nécessaires pour déployer un App Service, plan App Service, et un compte de stockage.

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

var appServicePlanSku = 'B1'
var appServicePlanCapacity = 1
var appServiceName = '${appServiceNamePrefix}${uniqueString(resourceGroup().id)}'
var linuxFxVersion = 'DOTNETCORE|8.0'

resource appServicePlan 'Microsoft.Web/serverfarms@2023-01-01' = {
  name: appServicePlanName
  location: location
  sku: {
    name: appServicePlanSku
    capacity: appServicePlanCapacity
  }
  kind: 'linux'
  properties: {
    zoneRedundant: false
    reserved: true
  }
}

resource appService 'Microsoft.Web/sites@2023-01-01' = {
  name: appServiceName
  location: location
  properties: {
    serverFarmId: appServicePlan.id
    httpsOnly: true
    redundancyMode: 'None'
    siteConfig: {
      linuxFxVersion: linuxFxVersion
      minTlsVersion: '1.2'
      ftpsState: 'Disabled'
    }
  }
}

output appServicePlan string = appServicePlanName
output appServiceApp string = appService.properties.defaultHostName

Convertir Bicep en JSON

Utilisez PowerShell ou Azure CLI pour générer le fichier mainTemplate.json. Accédez au répertoire dans lequel vous avez enregistré votre fichier Bicep et exécutez la build commande.

Azure PowerShell
Azure CLI

bicep build mainTemplate.bicep

az bicep build --file mainTemplate.bicep

Si vous souhaitez en savoir plus, accédez à la build Bicep.

Une fois le fichier Bicep converti en JSON, votre fichier mainTemplate.json doit correspondre à l’exemple suivant. Vous pouvez avoir des valeurs différentes dans les metadata propriétés pour version et templateHash.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "metadata": {
    "_generator": {
      "name": "bicep",
      "version": "0.30.3.12046",
      "templateHash": "16466621031230437685"
    }
  },
  "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]"
    }
  }
}

Définissez votre expérience du portail

En tant qu’éditeur, vous définissez l’expérience du portail pour créer l’application managée. Le fichier createUiDefinition.json génère l’interface utilisateur du portail. Vous définissez comment les utilisateurs fournissent une entrée pour chaque paramètre à l’aide d’éléments de contrôle tels que des listes déroulantes et des zones de texte.

Dans cet exemple, l’interface utilisateur vous invite à entrer le préfixe de nom App Service et le nom du plan App Service. Pendant le déploiement de mainTemplate.json, les variables appServiceName utilisent la fonction uniqueString pour ajouter une chaîne de 13 caractères au préfixe de nom afin de rendre le nom globalement unique dans Azure.

Ouvrez Visual Studio Code, créez un fichier avec le nom createUiDefinition.json (avec respect de la casse) et enregistrez-le.

Ajoutez le code JSON suivant au fichier, puis enregistrez-le.

{
  "$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]"
    }
  }
}

Pour en savoir plus, accédez à la page Démarrage avec CreateUiDefinition.

Empaqueter les fichiers

Ajoutez les deux fichiers au fichier de package nommé app.zip. Les deux fichiers doivent se trouver au niveau racine du fichier .zip. Si les fichiers sont dans un dossier, lorsque vous créez la définition d’application managée, une erreur vous indique que les fichiers nécessaires ne sont pas présents.

Chargez app.zip sur un compte de stockage Azure afin de pouvoir l’utiliser lorsque vous déployez la définition de l’application managée. Le nom du compte de stockage doit être globalement unique dans Azure, et la longueur doit être comprise entre trois et 24 caractères avec uniquement des lettres minuscules et des chiffres. Dans la commande, remplacez l’espace réservé <pkgstorageaccountname>, y compris les chevrons (<>), par le nom de votre compte de stockage unique.

Azure PowerShell
Azure CLI

Dans Visual Studio Code, ouvrez un nouveau terminal PowerShell et connectez-vous à votre abonnement Azure.

Connect-AzAccount

La commande ouvre votre navigateur par défaut et vous invite à vous connecter à Azure. Pour plus d’informations, accédez à Se connecter avec Azure PowerShell.

Après vous être connecté, exécutez les commandes suivantes.

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 variable $pkgstorageparms utilise PowerShell splatting pour améliorer la lisibilité des valeurs de paramètres utilisées dans la commande pour créer le nouveau compte de stockage. Splatting est utilisé dans d’autres commandes PowerShell qui utilisent plusieurs valeurs de paramètres.

Après avoir créé le compte de stockage, ajoutez l’attribution de rôle Contributeur aux données blob du stockage à l’étendue du compte de stockage. Attribuez l’accès à votre compte d’utilisateur Microsoft Entra. Selon votre niveau d’accès dans Azure, vous devrez peut-être disposer d’autres autorisations attribuées par votre administrateur. Pour plus d’informations, consultez Attribuer un rôle Azure pour accéder aux données blob et Attribuer des rôles Azure en utilisant le portail Azure.

Une fois que vous avez ajouté le rôle au compte de stockage, il faut quelques minutes pour qu’il soit actif dans Azure. Ensuite, vous pouvez créer le contexte nécessaire pour créer le conteneur et charger le fichier.

$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

Utilisez la commande suivante pour stocker l’URI du fichier de package dans une variable nommée packageuri. Vous utilisez la valeur de la variable lorsque vous déployez la définition de l’application managée.

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

Dans Visual Studio Code, ouvrez une nouvelle session de terminal Bash et connectez-vous à votre abonnement Azure. Par exemple, si vous avez installé Git, sélectionnez Git Bash.

az login

La commande ouvre votre navigateur par défaut et vous invite à vous connecter à Azure. Pour plus d’informations, accédez à Se connecter avec Azure CLI.

Après vous être connecté, exécutez les commandes suivantes.

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)

La barre oblique inverse (\) est un caractère de continuation de ligne pour améliorer la lisibilité des paramètres de la commande. Elle est utilisée dans la plupart des commandes Azure CLI. La variable pkgstgacct contient le nom du compte de stockage à utiliser dans d’autres commandes.

Après avoir créé le compte de stockage, ajoutez l’attribution de rôle Contributeur aux données blob du stockage à l’étendue du compte de stockage. Attribuez l’accès à votre compte d’utilisateur Microsoft Entra. Selon votre niveau d’accès dans Azure, vous devrez peut-être disposer d’autres autorisations attribuées par votre administrateur. Pour plus d’informations, accédez àAttribuer un rôle Azure pour accéder aux données blob.

Une fois que vous avez ajouté le rôle au compte de stockage, il faut quelques minutes pour qu’il soit actif dans Azure. Vous pouvez ensuite utiliser le paramètre --auth-mode login dans les commandes pour créer le conteneur et charger le fichier.

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"

Pour plus d’informations sur l’authentification du stockage, accédez àChoisir comment autoriser l’accès à des données blob avec Azure CLI.

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

Créer la définition d’application gérée

Dans cette section, vous obtenez des informations d’identité à partir de Microsoft Entra ID, créez un groupe de ressources et déployez la définition d’application managée.

Obtenir l’ID du groupe et l’ID de définition de rôle

L’étape suivante consiste à sélectionner un utilisateur, un groupe de sécurité ou une application afin de gérer les ressources pour le client. Cette identité dispose des autorisations sur le groupe de ressources managées en fonction du rôle attribué. Le rôle peut être n’importe quel rôle intégré Azure comme Propriétaire ou Contributeur.

Cet exemple utilise un groupe de sécurité et votre compte Microsoft Entra doit être membre du groupe. Pour obtenir l’ID d’objet du groupe, remplacez l’espace réservé <managedAppDemo>, y compris les chevrons (<>), par le nom de votre groupe. Vous utilisez la valeur de la variable lorsque vous déployez la définition de l’application managée.

Pour créer un groupe Microsoft Entra, accédez à Gérer les groupes Microsoft Entra et l’appartenance aux groupes.

Azure PowerShell
Azure CLI

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

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

Obtenez ensuite l’ID de définition de rôle du rôle intégré Azure auquel vous souhaitez accorder l’accès à l’utilisateur, au groupe ou à l’application. Vous utilisez la valeur de la variable lorsque vous déployez la définition de l’application managée.

Azure PowerShell
Azure CLI

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

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

Créer le modèle de déploiement de définition

Utilisez un fichier Bicep pour déployer la définition d’application managée dans votre catalogue de services.

Ouvrez Visual Studio Code, créez un fichier nommé deployDefinition.bicep et enregistrez-le.

Ajoutez le code Bicep suivant et enregistrez le fichier.

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

Pour plus d’informations sur les propriétés du modèle, accédez àMicrosoft.Solutions/applicationDefinitions.

Le lockLevel du groupe de ressources managées empêche le client d’effectuer des opérations indésirables sur ce groupe de ressources. Actuellement, ReadOnly est le seul niveau de verrou pris en charge. ReadOnly spécifie que le client peut uniquement lire les ressources présentes dans le groupe de ressources managées. Les identités de l’éditeur dont l’accès est octroyé au groupe de ressources managées sont exemptées du niveau verrou.

Créer le fichier de paramètres

Le modèle de déploiement de la définition d’application managée a besoin d’une entrée pour plusieurs paramètres. La commande de déploiement vous invite à entrer les valeurs ou vous pouvez créer un fichier de paramètres pour les valeurs. Dans cet exemple, nous utilisons un fichier de paramètres pour passer les valeurs des paramètres à la commande de déploiement.

Dans Visual Studio Code, créez un nouveau fichier nommé deployDefinition-parameters.bicepparam et enregistrez-le.

Ajoutez le code suivant à votre fichier de paramètres et enregistrez-le. Ensuite, remplacez le <placeholder values>, y compris les chevrons (<>), par vos valeurs.

using './deployDefinition.bicep'

param managedApplicationDefinitionName = 'sampleBicepManagedApplication'
param packageFileUri = '<placeholder for the packageFileUri>'
param principalId = '<placeholder for principalid value>'
param roleId = '<placeholder for roleid value>'

Le tableau suivant décrit les valeurs de paramètre de la définition d’application managée.

Paramètre	Valeur
`managedApplicationDefinitionName`	Nom de la définition d’application managée. Pour cet exemple, utilisez sampleBicepManagedApplication.
`packageFileUri`	Entrez l’URI de votre fichier de package .zip. Utilisez la valeur de votre variable `packageuri`.
`principalId`	ID du principal des éditeurs qui nécessite des autorisations pour gérer des ressources dans le groupe de ressources managées. Utilisez la valeur de votre variable `principalid`.
`roleId`	ID de rôle pour les autorisations du groupe de ressources managées. Par exemple Propriétaire, Contributeur, Lecteur. Utilisez la valeur de votre variable `roleid`.

Pour obtenir vos valeurs de variable :

Azure PowerShell : dans PowerShell, tapez $variableName pour afficher la valeur d’une variable.
Azure CLI : dans Bash, tapez echo $variableName pour afficher la valeur d’une variable.

Déployer la définition

Lorsque vous déployez la définition de l’application managée, elle est mise à disposition dans votre catalogue de services. Ce processus ne déploie pas les ressources de l’application managée.

Créez un groupe de ressources nommé bicepDefinitionGroup et déployez la définition d’application managée.

Azure PowerShell
Azure CLI

New-AzResourceGroup -Name bicepDefinitionGroup -Location westus

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

New-AzResourceGroupDeployment @deployparms

az group create --name bicepDefinitionGroup --location westus

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

Vérifier les résultats

Exécutez la commande suivante pour vérifier la publication de la définition dans votre catalogue de services.

Azure PowerShell
Azure CLI

Get-AzManagedApplicationDefinition -ResourceGroupName bicepDefinitionGroup

Get-AzManagedApplicationDefinition répertorie toutes les définitions disponibles dans le groupe de ressources spécifié, comme sampleBicepManagedApplication.

az managedapp definition list --resource-group bicepDefinitionGroup

La commande répertorie toutes les définitions disponibles dans le groupe de ressources spécifié, comme sampleBicepManagedApplication.

Assurez-vous que les utilisateurs peuvent accéder à votre définition

Vous avez accès à la définition de l’application managée, mais vous souhaitez vous assurer que d’autres utilisateurs de votre organisation peuvent y accéder. Accordez-leur au moins le rôle Lecteur dans la définition. Ils ont peut-être hérité de ce niveau d’accès depuis l’abonnement ou le groupe de ressources. Pour vérifier qui a accès à la définition et ajouter des utilisateurs ou des groupes, accédez à Attribuer des rôles Azure à l’aide du portail Azure.

Nettoyer les ressources

Si vous souhaitez déployer la définition, passez à la section Étapes suivantes qui établit un lien vers l’article pour déployer la définition avec Bicep.

Si vous avez terminé la définition d’application managée, vous pouvez supprimer les groupes de ressources que vous avez créés qui se nomment packageStorageGroup et bicepDefinitionGroup.

Azure PowerShell
Azure CLI

La commande vous invite à confirmer que vous souhaitez supprimer le groupe de ressources.

Remove-AzResourceGroup -Name packageStorageGroup

Remove-AzResourceGroup -Name bicepDefinitionGroup

La commande vous invite à confirmer, puis vous renvoie à l’invite de commandes pendant que les ressources sont supprimées.

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

az group delete --resource-group bicepDefinitionGroup --no-wait

Étapes suivantes

Vous avez publié la définition d’application managée. L’étape suivante consiste à apprendre à déployer une instance de cette définition.

Démarrage rapide : utiliser Bicep pour déployer une définition d’application managée Azure.

Partager via