Criar Aplicativo Gerenciado do Azure que implanta conta de armazenamento criptografada com chave gerenciada pelo cliente
Este artigo descreve como criar um Aplicativo Gerenciado do Azure que implanta uma conta de armazenamento criptografada usando uma chave gerenciada pelo cliente. A conta de armazenamento, o Cosmos DB e o Banco de Dados do Azure para Postgres oferecem suporte à criptografia de dados em repouso usando chaves gerenciadas pelo cliente ou chaves gerenciadas pela Microsoft. Você pode usar sua própria chave de criptografia para proteger os dados em sua conta de armazenamento. Quando especifica uma chave gerida pelo cliente, essa chave é utilizada para proteger e controlar o acesso à chave que encripta os seus dados. As chaves geridas pelo cliente oferecem uma maior flexibilidade para gerir os controlos de acesso.
Pré-requisitos
- Uma conta do Azure com uma assinatura ativa e permissões para recursos do Microsoft Entra, como usuários, grupos ou entidades de serviço. Se você não tiver uma conta, crie uma conta gratuita antes de começar.
- Código do Visual Studio com a extensão mais recente das Ferramentas do Azure Resource Manager. Para arquivos Bicep, instale a extensão Bicep para Visual Studio Code.
- Instale a versão mais recente do Azure PowerShell ou da CLI do Azure.
- Esteja familiarizado com como criar e implantar uma definição de catálogo de serviços.
Identidades geridas
Configurar uma chave gerenciada pelo cliente para uma conta de armazenamento implantada pelo aplicativo gerenciado como um recurso dentro do grupo de recursos gerenciados requer uma identidade gerenciada atribuída pelo usuário. Essa identidade gerenciada atribuída pelo usuário pode ser usada para conceder ao aplicativo gerenciado acesso a outros recursos existentes. Para saber como configurar seu aplicativo gerenciado com uma identidade gerenciada atribuída pelo usuário, vá para Aplicativo gerenciado do Azure com identidade gerenciada.
Pode conceder dois tipos de identidades à aplicação:
- Uma identidade gerenciada atribuída ao sistema é atribuída ao seu aplicativo e é excluída se o aplicativo for excluído. Um aplicativo só pode ter uma identidade gerenciada atribuída ao sistema.
- Uma identidade gerenciada atribuída pelo usuário é um recurso autônomo do Azure que pode ser atribuído ao seu aplicativo. Um aplicativo pode ter várias identidades gerenciadas atribuídas pelo usuário.
Para implantar uma conta de armazenamento no grupo de recursos gerenciados do aplicativo gerenciado criptografada com chaves de cliente do cofre de chaves existente, é necessária mais configuração. A identidade gerenciada configurada com seu aplicativo gerenciado precisa do Operador de Identidade Gerenciada de controle de acesso baseado em função interno do Azure sobre a identidade gerenciada que tem acesso ao cofre de chaves. Para obter mais detalhes, vá para a função Operador de Identidade Gerenciada.
Crie um cofre de chaves com proteção contra limpeza
- Inicie sessão no portal do Azure.
- No menu do portal do Azure ou na página inicial, selecione Criar um recurso.
- Na caixa Pesquisar, introduza Key Vault.
- Na lista de resultados, selecione Cofre da Chave.
- Na seção Cofre da Chave , selecione Criar.
- Na seção Criar cofre de chaves, forneça as seguintes informações:
- Subscrição: selecione a sua subscrição.
- Grupo de recursos: Selecione Criar novo e insira um nome como demo-cmek-rg.
- Nome: Um nome exclusivo é necessário, como demo-keyvault-cmek.
- Região: Selecione um local como Leste dos EUA.
- Nível de preço: selecione Padrão na lista suspensa.
- Proteção contra limpeza: selecione Ativar proteção contra limpeza.
- Selecione Avançar e vá para a guia Política de Acesso.
- Configuração de acesso: selecione Controle de acesso baseado em função do Azure.
- Aceite os padrões para todas as outras opções.
- Selecione Rever + criar.
- Confirme se as configurações estão corretas e selecione Criar.
Após a implantação bem-sucedida, selecione Ir para recurso. Na guia Visão geral, anote as seguintes propriedades:
- Nome do cofre: No exemplo, o nome do cofre é demo-keyvault-cmek. Use esse nome para outras etapas.
- URI do Vault: No exemplo, o URI do vault é
https://demo-keyvault-cmek.vault.azure.net/.
Criar uma identidade gerida atribuída pelo utilizador
Para criar uma identidade gerenciada atribuída pelo usuário, sua conta precisa da atribuição de função de Colaborador de identidade gerenciada.
- Na caixa de pesquisa, insira identidades gerenciadas.
- Em Serviços, selecione Identidades Gerenciadas.
- Selecione Criar e insira os seguintes valores na guia Noções básicas :
- Subscrição: selecione a sua subscrição.
- Grupo de recursos: selecione o grupo de recursos demo-cmek-rg que você criou nas etapas anteriores.
- Região: selecione uma região como Leste dos EUA.
- Nome: insira o nome da identidade gerenciada atribuída pelo usuário, como demokeyvaultmi.
- Selecione Rever + criar.
- Depois que a Validação Aprovada for exibida, selecione Criar.
Após uma implantação bem-sucedida, selecione Ir para recurso.
Criar atribuições de função
Você precisa criar duas atribuições de função para seu cofre de chaves. Para obter detalhes, consulte Atribuir funções do Azure usando o portal do Azure.
Conceder permissão de chave no cofre de chaves para a identidade gerenciada
Crie uma atribuição de função para a identidade gerenciada do cofre de chaves demokeyvaultmi para encapsular e desembrulhar chaves.
- Vá para o seu cofre de chaves demo-cmek-keyvault.
- Selecione Controlo de acesso (IAM) .
- Selecione Adicionar>Adicionar atribuição de função.
- Atribua a seguinte função:
- Função: Usuário de criptografia do Key Vault Crypto Service
- Atribuir acesso a: Identidade gerenciada
- Membro: demokeyvaultmi
- Selecione Rever + atribuir para ver as suas definições.
- Selecione Rever + atribuir para criar a atribuição de função.
Criar uma atribuição de função para a sua conta
Crie outra atribuição de função para que sua conta possa criar uma nova chave no cofre de chaves.
- Atribua a seguinte função:
- Função: Key Vault Crypto Officer
- Atribuir acesso a: Usuário, grupo ou entidade de serviço
- Membro: A sua conta Microsoft Entra
- Selecione Rever + atribuir para ver as suas definições.
- Selecione Rever + atribuir para criar a atribuição de função.
Você pode verificar as atribuições de função do cofre de chaves em Atribuições de função de controle de acesso (IAM)>.
Criar uma chave
Você precisa criar uma chave que seu cofre de chaves usa para criptografar uma conta de armazenamento.
- Vá para o cofre da chave, demo-cmek-keyvault.
- Selecione Chaves.
- Selecione Gerar/Importar.
- Na página Criar uma chave, selecione os seguintes valores:
- Opções: Gerar
- Nome: demo-cmek-key
- Aceite os padrões para as outras opções.
- Selecione Criar.
Anote o nome da chave. Você o usa quando implanta o aplicativo gerenciado.
Criar uma identidade gerenciada atribuída pelo usuário para o aplicativo gerenciado
Crie uma identidade gerenciada atribuída pelo usuário para ser usada como a identidade gerenciada para o aplicativo gerenciado.
- Na caixa de pesquisa, introduza Identidades Geridas.
- Em Serviços, selecione Identidades Gerenciadas.
- Selecione Criar.
- Subscrição: selecione a sua subscrição.
- Grupo de recursos: Selecione o grupo de recursos demo-cmek-rg.
- Região: selecione uma região como Leste dos EUA.
- Nome: insira o nome da identidade gerenciada atribuída pelo usuário, como demomanagedappmi.
- Selecione Rever + criar.
- Depois que a Validação Aprovada for exibida, selecione Criar.
Após uma implantação bem-sucedida, selecione Ir para recurso.
Atribuir permissão de função à identidade gerenciada
Atribua a função Operador de Identidade Gerenciada à identidade gerenciada no escopo da identidade gerenciada atribuída pelo usuário chamada demokeyvaultmi.
- Vá para a identidade gerenciada atribuída pelo usuário chamada demokeyvaultmi.
- Selecione Controlo de acesso (IAM) .
- Selecione Adicionar atribuição de função para abrir a página Adicionar>atribuição de função.
- Atribua a seguinte função.
- Função: Operador de identidade gerenciado
- Atribuir acesso a: Identidade gerenciada
- Membro: demomanagedappmi
- Selecione Rever + atribuir para ver as suas definições.
- Selecione Rever + atribuir para criar a atribuição de função.
Você pode verificar a atribuição de função para demokeyvaultmi em Controle de acesso (IAM)>Atribuições de função.
Exemplo de modelo de aplicativo gerenciado
Crie um aplicativo gerenciado que implante uma conta de armazenamento em um grupo de recursos gerenciados e use a chave de um cofre de chaves pré-existente para criptografar os dados na conta de armazenamento.
Para publicar um aplicativo gerenciado em seu catálogo de serviços, execute as seguintes tarefas:
- Crie o arquivo creatUIDefinition.json a partir do exemplo neste artigo. O modelo define os elementos da interface do usuário do portal ao implantar o aplicativo gerenciado.
- Crie um modelo do Azure Resource Manager chamado mainTemplate.json convertendo o arquivo Bicep neste artigo para JSON. O modelo define os recursos a serem implantados com o aplicativo gerenciado.
- Crie um pacote .zip que contenha os arquivos JSON necessários: createUiDefinition.json e mainTemplate.json.
- Publique a definição de aplicativo gerenciado para que ela esteja disponível em seu catálogo de serviços. Para obter mais informações, vá para Guia de início rápido: criar e publicar uma definição de Aplicativo Gerenciado do Azure.
Criar modelo createUiDefinition.json
O modelo a seguir cria uma identidade gerenciada atribuída pelo usuário para o aplicativo gerenciado. Neste exemplo, desabilitamos a identidade gerenciada atribuída ao sistema porque precisamos que nossa identidade gerenciada atribuída pelo usuário seja configurada antecipadamente com as permissões do Operador de Identidade Gerenciada sobre a identidade gerenciada do cofre de chaves.
- Crie um novo arquivo no Visual Studio Code chamado creatUIDefinition.json.
- Copie e cole o código a seguir no arquivo.
- Guarde o ficheiro.
{
"$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)]"
}
}
}
}
Criar modelo mainTemplate.json
O seguinte arquivo Bicep é o código-fonte para seu mainTemplate.json. O modelo usa a identidade gerenciada atribuída pelo usuário definida no arquivo createUiDefinition.json .
- Crie um novo arquivo no Visual Studio Code chamado mainTemplate.bicep.
- Copie e cole o código a seguir no arquivo.
- Guarde o ficheiro.
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}'
}
}
}
}
Use o PowerShell ou a CLI do Azure para criar o arquivo mainTemplate.json . Vá para o diretório onde você salvou seu arquivo Bicep e execute o build comando.
bicep build mainTemplate.bicep
Depois que o arquivo Bicep é convertido em JSON, seu arquivo mainTemplate.json deve corresponder ao exemplo a seguir. Você pode ter valores diferentes nas metadata propriedades de version e 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)]"
}
}
}
}
]
}
Implementar a aplicação gerida
Depois que a definição do catálogo de serviços for criada, você poderá implantar o aplicativo gerenciado. Para obter mais informações, vá para Guia de início rápido: implantar um aplicativo gerenciado do catálogo de serviços.
Durante a implantação, você usa suas identidades gerenciadas atribuídas pelo usuário, nome do cofre de chaves, URL do cofre de chaves, nome de chave do cofre de chaves. O arquivo createUiDefinition.json cria a interface de uso.
Por exemplo, em uma implantação de portal, na guia Configurações do aplicativo, você adiciona o demomanagedappmi.
Na guia Configuração, você habilita a chave gerenciada pelo cliente e adiciona a identidade gerenciada atribuída pelo usuário para o cofre de chaves, demokeyvaultmi. Você também especifica o URL do cofre de chaves e o nome da chave do cofre de chaves que você criou.
Verificar a implementação
Após a conclusão da implantação, você poderá verificar a atribuição de identidade do aplicativo gerenciado. A identidade gerenciada atribuída pelo usuário demomanagedappmi é atribuída ao aplicativo gerenciado.
- Vá para o grupo de recursos onde você implantou o aplicativo gerenciado.
- Em Configurações>de Identidade, selecione Usuário atribuído (visualização).
Você também pode verificar a conta de armazenamento que o aplicativo gerenciado implantou. A guia Criptografia mostra a chave demo-cmek-key e o ID do recurso para a identidade gerenciada atribuída pelo usuário.
- Vá para o grupo de recursos gerenciados onde a conta de armazenamento do aplicativo gerenciado está implantada.
- Em Segurança + rede , selecione Encriptação.
Próximos passos
- Para obter mais informações sobre criptografia de armazenamento, vá para Chaves gerenciadas pelo cliente para criptografia do Armazenamento do Azure.
- Para obter mais informações sobre a identidade gerenciada atribuída pelo usuário com permissões para acessar a chave no cofre de chaves, vá para Configurar chaves gerenciadas pelo cliente no mesmo locatário para uma conta de armazenamento existente.