Création d’une application managée Azure qui déploie un compte de stockage chiffré avec une clé gérée par le client
Cet article explique comment créer une application managée Azure qui déploie un compte de stockage chiffré à l’aide d’une clé gérée par le client. Le compte de stockage, Cosmos DB et Azure Database pour Postgres prennent en charge le chiffrement des données au repos à l’aide de clés gérées par le client ou de clés gérées par Microsoft. Vous pouvez utiliser votre propre clé de chiffrement pour protéger les données de votre compte de stockage. Quand vous spécifiez une clé gérée par le client, cette clé est utilisée pour protéger et contrôler l’accès à la clé qui chiffre vos données. Les clés gérées par le client offrent davantage de flexibilité pour gérer les contrôles d’accès.
Prérequis
- 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.
- Familiarisez-vous avec la création et le déploiement d’une définition de catalogue de services.
Identités managées
La configuration d’une clé gérée par le client pour un compte de stockage déployé par l’application managée en tant que ressource au sein du groupe de ressources managées nécessite une identité managée affectée par l’utilisateur. Cette identité managée affectée par l’utilisateur peut être utilisée pour octroyer à l’application managée l’accès à d’autres ressources existantes. Pour savoir comment configurer votre application managée avec une identité managée affectée par l’utilisateur, accédez à Application managée Azure avec identité managée.
Deux types d’identité peuvent être accordés à votre application :
- Une identité managée affectée par le système est attribuée à votre application et est supprimée si votre application est supprimée. Une application ne peut avoir qu’une seule identité managée attribuée par le système.
- Une identité managée attribuée par l’utilisateur est une ressource Azure autonome qui peut être attribuée à votre application. Une application peut avoir plusieurs identités managées attribuées par l’utilisateur.
Pour déployer un compte de stockage dans le groupe de ressources managées de votre application managée qui est chiffré avec des clés client à partir d’un coffre de clés existant, une configuration supplémentaire est nécessaire. L’identité managée configurée avec votre application managée a besoin de l’opérateur d’identité managée de contrôle d’accès en fonction du rôle Azure intégré sur l’identité managée qui a accès au coffre de clés. Pour plus d’informations, accédez au Rôle Opérateur d’identité managée.
Création d’un coffre de clés avec protection contre le vidage
- Connectez-vous au portail Azure.
- Dans le menu du Portail Azure ou dans la page Accueil, sélectionnez Créer une ressource.
- Dans la zone de recherche, entrez Key Vault.
- Dans la liste des résultats, sélectionnez Key Vault.
- Dans la section Key Vault (Coffre de clés), sélectionnez Créer.
- Dans la section Créer un coffre de clés, renseignez les informations suivantes :
- Abonnement : sélectionnez votre abonnement.
- Groupe de ressources : sélectionnez Créer et entrez un nom comme demo-cmek-rg.
- Nom : un nom unique est requis, par exemple demo-keyvault-cmek.
- Région : sélectionnez une localisation, comme USA Est.
- Niveau tarifaire : sélectionnez Standard dans la liste déroulante.
- Protection contre le vidage : sélectionnez Activer la protection contre le vidage.
- Sélectionnez Suivant et accédez à l’onglet Stratégie d’accès.
- Configuration de l’accès : sélectionnez Contrôle d’accès en fonction du rôle Azure.
- Acceptez les valeurs par défaut pour toutes les autres options.
- Sélectionnez Revoir + créer.
- Vérifiez que les paramètres sont corrects et sélectionnez Créer.
Une fois le déploiement réussi, sélectionnez Accéder à la ressource. Sous l’onglet Vue d’ensemble, notez les propriétés suivantes :
- Nom du coffre : dans l’exemple, le nom du coffre est demo-keyvault-cmek. Vous utilisez ce nom pour les autres étapes.
- URI du coffre : dans l’exemple, l’URI du coffre est
https://demo-keyvault-cmek.vault.azure.net/.
Créer une identité managée attribuée par l’utilisateur
Pour créer une identité managée affectée par l’utilisateur, votre compte a besoin de l’affectation de rôle Contributeur d’identité managée.
- Dans la zone de recherche, entrez Identités managées.
- Sous Services, sélectionnez Identités managées.
- Sélectionnez Créer et entrez les valeurs suivantes sous l’onglet Informations de base :
- Abonnement : sélectionnez votre abonnement.
- Groupe de ressources : sélectionnez le groupe de ressources demo-cmek-rg que vous avez créé au cours des étapes précédentes.
- Région : sélectionnez une région, par exemple USA Est.
- Nom de la ressource : entrez le nom de votre identité managée affectée par l’utilisateur, comme demokeyvaultmi.
- Sélectionnez Revoir + créer.
- Une fois Contrôle réussi affiché, sélectionnez Créer.
Une fois un déploiement réussi, sélectionnez Accéder à la ressource.
Créer des attributions de rôles
Vous devez créer deux attributions de rôles pour votre coffre de clés. Pour plus d’informations, consultez Attribution de rôles Azure à l’aide du Portail Microsoft Azure.
Octroi d’autorisation de clé sur le coffre de clés à l’identité managée
Créez une attribution de rôle pour l’identité managée du coffre de clés demokeyvaultmi afin d’envelopper et de désenvelopper les clés.
- Accédez à votre coffre de clés demo-cmek-keyvault.
- Sélectionnez Contrôle d’accès (IAM) .
- Sélectionnez Ajouter>Ajouter une attribution de rôle.
- Attribuez le rôle suivant :
- Rôle : Utilisateur du service de chiffrement de Key Vault
- Attribuer l’accès à : Identité managée
- Membre : demokeyvaultmi
- Sélectionnez Vérifier + attribuer pour passer en revue vos paramètres.
- Sélectionnez Vérifier + attribuer pour créer l’attribution de rôle.
Création d’une attribution de rôle pour votre compte
Créez une autre attribution de rôle afin que votre compte puisse créer une nouvelle clé dans votre coffre de clés.
- Attribuez le rôle suivant :
- Rôle : Agent de chiffrement Key Vault
- Attribuer l’accès à : Utilisateur, groupe ou principal de service
- Membre : votre compte Microsoft Entra
- Sélectionnez Vérifier + attribuer pour passer en revue vos paramètres.
- Sélectionnez Vérifier + attribuer pour créer l’attribution de rôle.
Vous pouvez vérifier les attributions de rôles du coffre de clés dans Contrôle d’accès (IAM)>Attributions de rôles.
Créer une clé
Vous devez créer une clé que votre coffre de clés utilise pour chiffrer un compte de stockage.
- Accédez à votre coffre de clés, demo-cmek-keyvault.
- Sélectionnez Clés.
- Sélectionnez Générer/Importer.
- Sur la page Créer une clé, choisissez les valeurs suivantes :
- Options : Générer
- Nom : demo-cmek-key
- Acceptez les valeurs par défaut pour les autres options.
- Sélectionnez Create (Créer).
Prenez note du nom de la clé. Vous l’utilisez lorsque vous déployez l’application managée.
Création d’une identité managée affectée par l’utilisateur pour l’application managée
Créez une identité managée affectée par l’utilisateur à utiliser comme identité managée pour l’application managée.
- Dans la zone de recherche, entrez Identités managées.
- Sous Services, sélectionnez Identités managées.
- Sélectionnez Create (Créer).
- Abonnement : sélectionnez votre abonnement.
- Groupe de ressources : sélectionnez le groupe de ressources demo-cmek-rg.
- Région : sélectionnez une région, par exemple USA Est.
- Nom de la ressource : entrez le nom de votre identité managée affectée par l’utilisateur, comme demomanagedappmi.
- Sélectionnez Revoir + créer.
- Une fois Contrôle réussi affiché, sélectionnez Créer.
Une fois un déploiement réussi, sélectionnez Accéder à la ressource.
Attribution d’une autorisation de rôle à une identité managée
Attribuez le rôle Opérateur d’identité managée à l’identité managée au niveau de l’étendue de l’identité managée affectée par l’utilisateur nommée demokeyvaultmi.
- Accédez à l’identité managée affectée par l’utilisateur nommée demokeyvaultmi.
- Sélectionnez Contrôle d’accès (IAM).
- Sélectionnez Ajouter>Ajouter une attribution de rôle pour ouvrir la page Ajouter une attribution de rôle.
- Attribuez le rôle suivant.
- Rôle : Opérateur d’identités managées
- Attribuer l’accès à : Identité managée
- Membre : demomanagedappmi
- Sélectionnez Vérifier + attribuer pour passer en revue vos paramètres.
- Sélectionnez Vérifier + attribuer pour créer l’attribution de rôle.
Vous pouvez vérifier l’attribution de rôle pour demokeyvaultmi dans Contrôle d’accès (IAM)>Attributions de rôles.
Exemple de modèle d’application managée
Créez une application managée qui déploie un compte de stockage dans un groupe de ressources managées et utilisez la clé d’un coffre de clés préexistante pour chiffrer les données dans le compte de stockage.
Pour publier une application managée dans votre catalogue de services, effectuez les tâches suivantes :
- Créez le fichier creatUIDefinition.json à partir de l’exemple de cet article. Le modèle définit les éléments d’interface utilisateur du portail lors du déploiement de l’application managée.
- Créez un modèle Azure Resource Manager nommé mainTemplate.json en convertissant le fichier Bicep de cet article en JSON. Le modèle définit les ressources à déployer avec l’application managée.
- Créez un package .zip qui contient les fichiers JSON requis : createUiDefinition.json et mainTemplate.json.
- Publiez la définition d’application managée pour qu’elle soit disponible dans votre catalogue de services. Pour plus d’informations, consultez Démarrage rapide : créer et publier une définition d’application managée Azure.
Création d’un modèle createUiDefinition.json
Le modèle suivant crée une identité managée affectée par l’utilisateur pour l’application managée. Dans cet exemple, nous désactivons l’identité managée affectée par le système, car nous avons besoin que notre identité managée affectée par l’utilisateur soit configurée à l’avance avec les autorisations d’opérateur d’identité managée sur l’identité managée du coffre de clés.
- Créez un nouveau fichier dans Visual Studio Code nommé creatUIDefinition.json.
- Copiez et collez le code suivant dans le fichier.
- Enregistrez le fichier .
{
"$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": "managedApplicationSetting",
"label": "Application Settings",
"subLabel": {
"preValidation": "Configure your application settings and Managed Identity for the application",
"postValidation": "Done"
},
"bladeTitle": "Application Settings - Config",
"elements": [
{
"name": "appIdentity",
"type": "Microsoft.ManagedIdentity.IdentitySelector",
"label": "Managed Identity Configuration for the Application (Needs Managed Identity Operator permissions over KV Managed Identity).",
"toolTip": {
"systemAssignedIdentity": "Enable system assigned identity to grant the managed application access to additional existing resources.",
"userAssignedIdentity": "Add user assigned identities to grant the managed application access to additional existing resources."
},
"defaultValue": {
"systemAssignedIdentity": "Off"
},
"options": {
"hideSystemAssignedIdentity": true,
"hideUserAssignedIdentity": false,
"readOnlySystemAssignedIdentity": true
},
"visible": true
}
]
},
{
"name": "configuration",
"type": "Microsoft.Common.Section",
"label": "Configuration",
"elements": [
{
"name": "cmek",
"type": "Microsoft.Common.Section",
"label": "Customer Managed Encryption Key (CMEK)",
"elements": [
{
"name": "cmekEnable",
"type": "Microsoft.Common.CheckBox",
"label": "Enable CMEK",
"toolTip": "Enable to provide a CMEK",
"constraints": {
"required": false
}
},
{
"name": "cmekKeyVaultUrl",
"type": "Microsoft.Common.TextBox",
"label": "Key Vault URL",
"toolTip": "Specify the CMEK Key Vault URL",
"defaultValue": "",
"constraints": {
"required": "[steps('configuration').cmek.cmekEnable]",
"regex": ".*",
"validationMessage": "The value must not be empty."
},
"visible": "[steps('configuration').cmek.cmekEnable]"
},
{
"name": "cmekKeyName",
"type": "Microsoft.Common.TextBox",
"label": "Key Name",
"toolTip": "Specify the key name from your key vault.",
"defaultValue": "",
"constraints": {
"required": "[steps('configuration').cmek.cmekEnable]",
"regex": ".*",
"validationMessage": "The value must not be empty."
},
"visible": "[steps('configuration').cmek.cmekEnable]"
},
{
"name": "cmekKeyIdentity",
"type": "Microsoft.ManagedIdentity.IdentitySelector",
"label": "Managed Identity Configuration for Key Vault Access",
"toolTip": {
"systemAssignedIdentity": "Enable system assigned identity to grant the managed application access to additional existing resources.",
"userAssignedIdentity": "Add user assigned identities to grant the managed application access to additional existing resources."
},
"defaultValue": {
"systemAssignedIdentity": "Off"
},
"options": {
"hideSystemAssignedIdentity": true,
"hideUserAssignedIdentity": false,
"readOnlySystemAssignedIdentity": true
},
"visible": "[steps('configuration').cmek.cmekEnable]"
}
],
"visible": true
}
]
}
],
"outputs": {
"location": "[location()]",
"managedIdentity": "[steps('managedApplicationSetting').appIdentity]",
"cmekConfig": {
"kvUrl": "[if(empty(steps('configuration').cmek.cmekKeyVaultUrl), '', steps('configuration').cmek.cmekKeyVaultUrl)]",
"keyName": "[if(empty(steps('configuration').cmek.cmekKeyName), '', steps('configuration').cmek.cmekKeyName)]",
"identityId": "[if(empty(steps('configuration').cmek.cmekKeyIdentity), '', steps('configuration').cmek.cmekKeyIdentity)]"
}
}
}
}
Création d’un modèle mainTemplate.json
Le fichier Bicep suivant est le code source de votre fichier mainTemplate.json. Le modèle utilise l’identité managée affectée par l’utilisateur définie dans le fichier createUiDefinition.json.
- Créez un nouveau fichier dans Visual Studio Code nommé mainTemplate.bicep.
- Copiez et collez le code suivant dans le fichier.
- Enregistrez le fichier .
param cmekConfig object = {
kvUrl: ''
keyName: ''
identityId: {}
}
@description('Specify the Azure region to place the application definition.')
param location string = resourceGroup().location
/////////////////////////////////
// Common Resources Configuration
/////////////////////////////////
var commonproperties = {
name: 'cmekdemo'
displayName: 'Common Resources'
storage: {
sku: 'Standard_LRS'
kind: 'StorageV2'
accessTier: 'Hot'
minimumTlsVersion: 'TLS1_2'
}
}
var identity = items(cmekConfig.identityId.userAssignedIdentities)[0].key
resource storage 'Microsoft.Storage/storageAccounts@2022-05-01' = {
name: '${commonproperties.name}${uniqueString(resourceGroup().id)}'
location: location
sku: {
name: commonproperties.storage.sku
}
kind: commonproperties.storage.kind
identity: cmekConfig.identityId
properties: {
accessTier: commonproperties.storage.accessTier
minimumTlsVersion: commonproperties.storage.minimumTlsVersion
encryption: {
identity: {
userAssignedIdentity: identity
}
services: {
blob: {
enabled: true
}
table: {
enabled: true
}
file: {
enabled: true
}
}
keySource: 'Microsoft.Keyvault'
keyvaultproperties: {
keyname: '${cmekConfig.keyName}'
keyvaulturi: '${cmekConfig.kvUrl}'
}
}
}
}
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.
bicep build mainTemplate.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.16.2.56959",
"templateHash": "1234567891234567890"
}
},
"parameters": {
"cmekConfig": {
"type": "object",
"defaultValue": {
"kvUrl": "",
"keyName": "",
"identityId": {}
}
},
"location": {
"type": "string",
"defaultValue": "[resourceGroup().location]",
"metadata": {
"description": "Specify the Azure region to place the application definition."
}
}
},
"variables": {
"commonproperties": {
"name": "cmekdemo",
"displayName": "Common Resources",
"storage": {
"sku": "Standard_LRS",
"kind": "StorageV2",
"accessTier": "Hot",
"minimumTlsVersion": "TLS1_2"
}
},
"identity": "[items(parameters('cmekConfig').identityId.userAssignedIdentities)[0].key]"
},
"resources": [
{
"type": "Microsoft.Storage/storageAccounts",
"apiVersion": "2022-05-01",
"name": "[format('{0}{1}', variables('commonproperties').name, uniqueString(resourceGroup().id))]",
"location": "[parameters('location')]",
"sku": {
"name": "[variables('commonproperties').storage.sku]"
},
"kind": "[variables('commonproperties').storage.kind]",
"identity": "[parameters('cmekConfig').identityId]",
"properties": {
"accessTier": "[variables('commonproperties').storage.accessTier]",
"minimumTlsVersion": "[variables('commonproperties').storage.minimumTlsVersion]",
"encryption": {
"identity": {
"userAssignedIdentity": "[variables('identity')]"
},
"services": {
"blob": {
"enabled": true
},
"table": {
"enabled": true
},
"file": {
"enabled": true
}
},
"keySource": "Microsoft.Keyvault",
"keyvaultproperties": {
"keyname": "[format('{0}', parameters('cmekConfig').keyName)]",
"keyvaulturi": "[format('{0}', parameters('cmekConfig').kvUrl)]"
}
}
}
}
]
}
Déployer l’application managée
Une fois la définition du catalogue de services créée, vous pouvez déployer l’application managée. Pour plus d’informations, consultez Démarrage rapide : Déployer une application managée de catalogue de services.
Pendant le déploiement, vous utilisez vos identités managées affectées par l’utilisateur, le nom du coffre de clés, l’URL du coffre de clés, le nom de clé du coffre de clés. Le fichier createUiDefinition.json crée l’interface d’utilisation.
Par exemple, dans un déploiement de portail, sous l’onglet Paramètres de l’application, vous ajoutez demomanagedappmi.
Sous l’onglet Configuration, vous activez la clé gérée par le client et ajoutez l’identité managée affectée par l’utilisateur pour le coffre de clés, demokeyvaultmi. Vous spécifiez également l’URL du coffre de clés et le nom de clé du coffre de clés que vous avez créé.
Vérifier le déploiement
Une fois le déploiement terminé, vous pouvez vérifier l’attribution d’identité de l’application managée. L’identité managée affectée par l’utilisateur demomanagedappmi est affectée à l’application managée.
- Accédez au groupe de ressources dans lequel vous avez déployé l’application managée.
- Sous Paramètres>Identité, sélectionnez Affecté par l’utilisateur (préversion).
Vous pouvez également vérifier le compte de stockage déployé par l’application managée. L’onglet Chiffrement affiche la clé demo-cmek-key et l’ID de ressource de l’identité managée affectée par l’utilisateur.
- Accédez au groupe de ressources managées où le compte de stockage de l’application managée est déployé.
- Sous Sécurité + mise en réseau, sélectionnez Chiffrement.
Étapes suivantes
- Pour plus d’informations sur le chiffrement du stockage, consultez Clés gérées par le client pour le chiffrement du Stockage Microsoft Azure.
- Pour plus d’informations sur l’identité managée affectée par l’utilisateur avec des autorisations d’accès à la clé dans le coffre de clés, consultez Configurer des clés gérées par le client dans le même locataire pour un compte de stockage existant.