Tworzenie aplikacji zarządzanej platformy Azure, która wdraża konto magazynu zaszyfrowane przy użyciu klucza zarządzanego przez klienta
W tym artykule opisano sposób tworzenia aplikacji zarządzanej platformy Azure, która wdraża konto magazynu zaszyfrowane przy użyciu klucza zarządzanego przez klienta. Konto magazynu, usługa Cosmos DB i usługa Azure Database for Postgres obsługują szyfrowanie danych magazynowanych przy użyciu kluczy zarządzanych przez klienta lub kluczy zarządzanych przez firmę Microsoft. Możesz użyć własnego klucza szyfrowania, aby chronić dane na koncie magazynu. Gdy określisz klucz zarządzany przez klienta, ten klucz będzie używany w celu ochrony i kontroli dostępu do klucza szyfrującego dane. Klucze zarządzane przez klienta zapewniają większą elastyczność zarządzania kontrolą dostępu.
Wymagania wstępne
- Konto platformy Azure z aktywną subskrypcją i uprawnieniami do zasobów firmy Microsoft Entra, takich jak użytkownicy, grupy lub jednostki usługi. Jeśli nie masz konta, przed rozpoczęciem utwórz bezpłatne konto .
- Program Visual Studio Code z najnowszym rozszerzeniem narzędzi usługi Azure Resource Manager. W przypadku plików Bicep zainstaluj rozszerzenie Bicep dla programu Visual Studio Code.
- Zainstaluj najnowszą wersję programu Azure PowerShell lub interfejsu wiersza polecenia platformy Azure.
- Zapoznaj się z tworzeniem i wdrażaniem definicji katalogu usług.
Tożsamości zarządzane
Skonfigurowanie klucza zarządzanego przez klienta dla konta magazynu wdrożonego przez aplikację zarządzaną jako zasób w zarządzanej grupie zasobów wymaga tożsamości zarządzanej przypisanej przez użytkownika. Tej tożsamości zarządzanej przypisanej przez użytkownika można użyć do udzielenia aplikacji zarządzanej dostępu do innych istniejących zasobów. Aby dowiedzieć się, jak skonfigurować aplikację zarządzaną przy użyciu tożsamości zarządzanej przypisanej przez użytkownika, przejdź do pozycji Aplikacja zarządzana platformy Azure z tożsamością zarządzaną.
Aplikacja może mieć korzystać z dwóch typów tożsamości:
- Tożsamość zarządzana przypisana przez system jest przypisywana do aplikacji i usuwana, jeśli aplikacja zostanie usunięta. Aplikacja może mieć tylko jedną tożsamość zarządzaną przypisaną przez system.
- Tożsamość zarządzana przypisana przez użytkownika to autonomiczny zasób platformy Azure, który można przypisać do aplikacji. Aplikacja może mieć wiele tożsamości zarządzanych przypisanych przez użytkownika.
Aby wdrożyć konto magazynu w zarządzanej grupie zasobów aplikacji zarządzanej, która jest szyfrowana przy użyciu kluczy klienta z istniejącego magazynu kluczy, wymagana jest większa konfiguracja. Tożsamość zarządzana skonfigurowana za pomocą aplikacji zarządzanej wymaga wbudowanego operatora tożsamości zarządzanej kontroli dostępu opartej na rolach platformy Azure za pośrednictwem tożsamości zarządzanej, która ma dostęp do magazynu kluczy. Aby uzyskać więcej informacji, przejdź do roli Operator tożsamości zarządzanej.
Tworzenie magazynu kluczy z ochroną przeczyszczania
- Zaloguj się w witrynie Azure Portal.
- W menu witryny Azure Portal lub na stronie głównej wybierz pozycję Utwórz zasób.
- W polu wyszukiwania wpisz Key Vault.
- Z listy wyników wybierz pozycję Key Vault.
- W sekcji Key Vault wybierz pozycję Utwórz.
- W sekcji Tworzenie magazynu kluczy podaj następujące informacje:
- Subskrypcja: wybierz swoją subskrypcję.
- Grupa zasobów: wybierz pozycję Utwórz nową i wprowadź nazwę, taką jak demo-cmek-rg.
- Nazwa: wymagana jest unikatowa nazwa, na przykład demo-keyvault-cmek.
- Region: wybierz lokalizację, na przykład Wschodnie stany USA.
- Warstwa cenowa: wybierz pozycję Standardowa z listy rozwijanej.
- Ochrona przed przeczyszczaniem: wybierz pozycję Włącz ochronę przeczyszczania.
- Wybierz pozycję Dalej i przejdź do karty Zasady dostępu.
- Konfiguracja dostępu: wybierz pozycję Kontrola dostępu oparta na rolach platformy Azure.
- Zaakceptuj wartości domyślne dla wszystkich pozostałych opcji.
- Wybierz pozycję Przejrzyj i utwórz.
- Upewnij się, że ustawienia są poprawne, a następnie wybierz pozycję Utwórz.
Po pomyślnym wdrożeniu wybierz pozycję Przejdź do zasobu. Na karcie Przegląd zanotuj następujące właściwości:
- Nazwa magazynu: w przykładzie nazwa magazynu to demo-keyvault-cmek. Ta nazwa jest używana w innych krokach.
- Identyfikator URI magazynu: w tym przykładzie identyfikator URI magazynu to
https://demo-keyvault-cmek.vault.azure.net/.
Tworzenie tożsamości zarządzanej przypisanej przez użytkownika
Aby utworzyć tożsamość zarządzaną przypisaną przez użytkownika, twoje konto wymaga przypisania roli Współautor tożsamości zarządzanej.
- W polu wyszukiwania wprowadź tożsamości zarządzane.
- W obszarze Usługi wybierz pozycję Tożsamości zarządzane.
- Wybierz pozycję Utwórz i wprowadź następujące wartości na karcie Podstawy :
- Subskrypcja: wybierz swoją subskrypcję.
- Grupa zasobów: wybierz grupę zasobów demo-cmek-rg utworzoną w poprzednich krokach.
- Region: wybierz region, taki jak Wschodnie stany USA.
- Nazwa: wprowadź nazwę tożsamości zarządzanej przypisanej przez użytkownika, na przykład demokeyvaultmi.
- Wybierz pozycję Przejrzyj i utwórz.
- Po wyświetleniu pozycji Weryfikacja przekazana wybierz pozycję Utwórz.
Po pomyślnym wdrożeniu wybierz pozycję Przejdź do zasobu.
Tworzenie przypisań roli
Musisz utworzyć dwa przypisania ról dla magazynu kluczy. Aby uzyskać szczegółowe informacje, zobacz Przypisywanie ról platformy Azure przy użyciu witryny Azure Portal.
Udzielanie uprawnień klucza w magazynie kluczy do tożsamości zarządzanej
Utwórz przypisanie roli dla tożsamości zarządzanej magazynu kluczy demokeyvaultmi , aby opakowować i odpakowywać klucze.
- Przejdź do magazynu kluczy demo-cmek-keyvault.
- Wybierz pozycję Kontrola dostępu (IAM) .
- Wybierz pozycję Dodaj>Dodaj przypisanie roli.
- Przypisz następującą rolę:
- Rola: Użytkownik szyfrowania usługi kryptograficznej usługi Key Vault
- Przypisywanie dostępu do: tożsamość zarządzana
- Członek: demokeyvaultmi
- Wybierz pozycję Przejrzyj i przypisz , aby wyświetlić ustawienia.
- Wybierz pozycję Przejrzyj i przypisz , aby utworzyć przypisanie roli.
Tworzenie przypisania roli dla konta
Utwórz kolejne przypisanie roli, aby twoje konto może utworzyć nowy klucz w magazynie kluczy.
- Przypisz następującą rolę:
- Rola: Key Vault Crypto Officer
- Przypisywanie dostępu do: użytkownik, grupa lub jednostka usługi
- Członek: Twoje konto Microsoft Entra
- Wybierz pozycję Przejrzyj i przypisz , aby wyświetlić ustawienia.
- Wybierz pozycję Przejrzyj i przypisz , aby utworzyć przypisanie roli.
Przypisania ról magazynu kluczy można sprawdzić w obszarze Przypisania ról kontroli dostępu (IAM).>
Utwórz klucz
Musisz utworzyć klucz używany przez magazyn kluczy do szyfrowania konta magazynu.
- Przejdź do magazynu kluczy demo-cmek-keyvault.
- Wybierz pozycję Klucze.
- Wybierz Generuj/Import.
- Na stronie Tworzenie klucza wybierz następujące wartości:
- Opcje: Generowanie
- Nazwa: demo-cmek-key
- Zaakceptuj wartości domyślne dla innych opcji.
- Wybierz pozycję Utwórz.
Zanotuj nazwę klucza. Jest ona używana podczas wdrażania aplikacji zarządzanej.
Tworzenie tożsamości zarządzanej przypisanej przez użytkownika dla aplikacji zarządzanej
Utwórz tożsamość zarządzaną przypisaną przez użytkownika, która ma być używana jako tożsamość zarządzana dla aplikacji zarządzanej.
- W polu wyszukiwania wprowadź tożsamości zarządzane.
- W obszarze Usługi wybierz pozycję Tożsamości zarządzane.
- Wybierz pozycję Utwórz.
- Subskrypcja: wybierz swoją subskrypcję.
- Grupa zasobów: wybierz grupę zasobów demo-cmek-rg.
- Region: wybierz region, taki jak Wschodnie stany USA.
- Nazwa: wprowadź nazwę tożsamości zarządzanej przypisanej przez użytkownika, na przykład demomanagedappmi.
- Wybierz pozycję Przejrzyj i utwórz.
- Po wyświetleniu pozycji Weryfikacja przekazana wybierz pozycję Utwórz.
Po pomyślnym wdrożeniu wybierz pozycję Przejdź do zasobu.
Przypisywanie uprawnień roli do tożsamości zarządzanej
Przypisz rolę Operator tożsamości zarządzanej do tożsamości zarządzanej w zakresie tożsamości zarządzanej przypisanej przez użytkownika o nazwie demokeyvaultmi.
- Przejdź do tożsamości zarządzanej przypisanej przez użytkownika o nazwie demokeyvaultmi.
- Wybierz pozycję Kontrola dostępu (IAM) .
- Wybierz pozycję Dodaj>przypisanie roli, aby otworzyć stronę Dodawanie przypisania roli.
- Przypisz następującą rolę.
- Rola: Operator tożsamości zarządzanej
- Przypisywanie dostępu do: tożsamość zarządzana
- Członek: demomanagedappmi
- Wybierz pozycję Przejrzyj i przypisz , aby wyświetlić ustawienia.
- Wybierz pozycję Przejrzyj i przypisz , aby utworzyć przypisanie roli.
Przypisanie roli dla funkcji demokeyvaultmi można sprawdzić w temacie Kontrola dostępu (IAM)>Przypisania ról.
Przykładowy szablon aplikacji zarządzanej
Utwórz aplikację zarządzaną, która wdraża konto magazynu w zarządzanej grupie zasobów i używa istniejącego klucza magazynu kluczy do szyfrowania danych na koncie magazynu.
Aby opublikować aplikację zarządzaną w katalogu usług, wykonaj następujące zadania:
- Utwórz plik creatUIDefinition.json z przykładu w tym artykule. Szablon definiuje elementy interfejsu użytkownika portalu podczas wdrażania aplikacji zarządzanej.
- Utwórz szablon usługi Azure Resource Manager o nazwie mainTemplate.json , konwertując plik Bicep w tym artykule na format JSON. Szablon definiuje zasoby do wdrożenia za pomocą aplikacji zarządzanej.
- Utwórz pakiet zip zawierający wymagane pliki JSON: createUiDefinition.json i mainTemplate.json.
- Opublikuj definicję aplikacji zarządzanej, aby była dostępna w katalogu usług. Aby uzyskać więcej informacji, zobacz Szybki start: tworzenie i publikowanie definicji aplikacji zarządzanej platformy Azure.
Tworzenie pliku createUiDefinition.json
Poniższy szablon tworzy tożsamość zarządzaną przypisaną przez użytkownika dla aplikacji zarządzanej. W tym przykładzie wyłączymy tożsamość zarządzaną przypisaną przez system, ponieważ potrzebujemy, aby tożsamość zarządzana przypisana przez użytkownika została skonfigurowana z wyprzedzeniem z uprawnieniami operatora tożsamości zarządzanej za pośrednictwem tożsamości zarządzanej magazynu kluczy.
- Utwórz nowy plik w programie Visual Studio Code o nazwie creatUIDefinition.json.
- Skopiuj i wklej następujący kod do pliku.
- Zapisz plik.
{
"$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)]"
}
}
}
}
Tworzenie pliku mainTemplate.json szablonu
Poniższy plik Bicep jest kodem źródłowym pliku mainTemplate.json. Szablon używa przypisanej przez użytkownika tożsamości zarządzanej zdefiniowanej w pliku createUiDefinition.json .
- Utwórz nowy plik w programie Visual Studio Code o nazwie mainTemplate.bicep.
- Skopiuj i wklej następujący kod do pliku.
- Zapisz plik.
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}'
}
}
}
}
Użyj programu PowerShell lub interfejsu wiersza polecenia platformy Azure, aby skompilować plik mainTemplate.json . Przejdź do katalogu, w którym zapisano plik Bicep i uruchom build polecenie .
bicep build mainTemplate.bicep
Po przekonwertowaniu pliku Bicep na format JSON plik mainTemplate.json powinien być zgodny z poniższym przykładem. Mogą istnieć różne wartości we właściwościach metadata i version 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)]"
}
}
}
}
]
}
Wdrażanie aplikacji zarządzanej
Po utworzeniu definicji wykazu usług można wdrożyć aplikację zarządzaną. Aby uzyskać więcej informacji, przejdź do przewodnika Szybki start: wdrażanie aplikacji zarządzanej katalogu usług.
Podczas wdrażania używasz tożsamości zarządzanych przypisanych przez użytkownika, nazwy magazynu kluczy, adresu URL magazynu kluczy, nazwy klucza magazynu kluczy. Plik createUiDefinition.json tworzy interfejs use.
Na przykład we wdrożeniu portalu na karcie Aplikacja Ustawienia należy dodać aplikację demomanagedappmi.
Na karcie Konfiguracja włączysz klucz zarządzany przez klienta i dodasz tożsamość zarządzaną przypisaną przez użytkownika dla magazynu kluczy demokeyvaultmi. Należy również określić adres URL magazynu kluczy i utworzoną nazwę klucza magazynu kluczy.
Weryfikowanie wdrożenia
Po zakończeniu wdrażania można zweryfikować przypisanie tożsamości aplikacji zarządzanej. Tożsamość zarządzana przypisana przez użytkownika demomanagedappmi jest przypisana do aplikacji zarządzanej.
- Przejdź do grupy zasobów, w której wdrożono aplikację zarządzaną.
- W obszarze Ustawienia> Identity wybierz pozycję Użytkownik przypisany (wersja zapoznawcza).
Możesz również sprawdzić konto magazynu, które zostało wdrożone przez aplikację zarządzaną. Karta Szyfrowanie zawiera klucz demo-cmek-key i identyfikator zasobu tożsamości zarządzanej przypisanej przez użytkownika.
- Przejdź do zarządzanej grupy zasobów, w której jest wdrażane konto magazynu aplikacji zarządzanej.
- W obszarze Zabezpieczenia i sieć wybierz pozycję Szyfrowanie.
Następne kroki
- Aby uzyskać więcej informacji na temat szyfrowania magazynu, zobacz Klucze zarządzane przez klienta na potrzeby szyfrowania usługi Azure Storage.
- Aby uzyskać więcej informacji na temat tożsamości zarządzanej przypisanej przez użytkownika z uprawnieniami dostępu do klucza w magazynie kluczy, przejdź do tematu Konfigurowanie kluczy zarządzanych przez klienta w tej samej dzierżawie dla istniejącego konta magazynu.