Criar um Aplicativo Gerenciado do Azure que implanta a conta de armazenamento criptografada com uma 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 são compatíveis com a criptografia de dados em repouso, usando chaves gerenciadas pelo cliente ou chaves gerenciadas pela Microsoft. Você pode usar a própria chave de criptografia para proteger os dados em sua conta de armazenamento. Quando você especifica uma chave gerenciada pelo cliente, essa chave é usada para proteger e controlar o acesso à chave que criptografa os dados. Chaves gerenciadas pelo cliente oferecem maior flexibilidade para gerenciar controles 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ê ainda não tiver uma conta, crie uma conta gratuita antes de começar.
- Visual Studio Code com a extensão Ferramentas do Resource Manager mais recente. 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.
- Informe-se sobre como criar e implantar uma definição de catálogo de serviços.
Identidades gerenciadas
A configuração de 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, acesse Aplicativo Gerenciado do Azure com identidade gerenciada.
Seu aplicativo pode receber dois tipos de identidades:
- Uma identidade gerenciada atribuída pelo sistema é atribuída ao seu aplicativo e será excluída se o seu aplicativo for excluído. Um aplicativo só pode ter uma identidade gerenciada atribuída pelo 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 seu aplicativo gerenciado que tiver sido criptografado com chaves do cliente do cofre de chaves existente, mais configuração será necessária. A identidade gerenciada configurada com seu aplicativo gerenciado precisa de um Operador de Identidades Gerenciadas integrado do Azure com controle de acesso baseado em função sobre a identidade gerenciada que tenha acesso ao cofre de chaves. Para obter mais detalhes, vá para a Função de Operador de Identidades Gerenciadas.
Criar um cofre de chaves com proteção contra limpeza
- Entre no portal do Azure.
- No menu do portal do Azure ou na página Início, selecione Criar um recurso.
- Digite Key Vault na caixa Pesquisar.
- Na lista de resultados, selecione Key Vault.
- Na seção Cofre de Chaves, selecione Criar.
- Na seção “Criar cofre de chaves”, forneça as seguintes informações:
- Assinatura: Selecione sua assinatura.
- Grupo de Recursos: selecione Criar novo e insira um nome como, por exemplo, demo-cmek-rg.
- Nome: é obrigatório um nome exclusivo, como, por exemplo, demo-keyvault-cmek.
- Região: selecione um local, como Oeste dos EUA.
- Nível de preço: selecione Standard na lista suspensa.
- Proteção contra limpeza: selecione Habilitar 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 as configurações padrão para todas as outras opções.
- Selecione Examinar + criar.
- Confirme se as configurações estão corretas e selecione Criar.
Após a implantação bem-sucedida, selecione Ir para o recurso. Na guia Visão Geral, observe e anote as seguintes propriedades:
- Nome do cofre: no exemplo, o nome do cofre é demo-keyvault-cmek. Você usará esse nome nas outras etapas.
- URI do cofre: no exemplo, o URI do cofre é
https://demo-keyvault-cmek.vault.azure.net/.
Criar uma identidade gerenciada atribuída ao usuário
Para criar uma identidade gerenciada atribuída pelo usuário, sua conta precisa da atribuição de função de identidade gerenciada Colaborador.
- Na caixa de pesquisa, insira Identidades gerenciadas.
- Em Serviços, selecione Identidades Gerenciadas.
- Selecione Criar e insira os seguintes valores na guia Elementos Básicos:
- Assinatura: Selecione sua assinatura.
- Grupo de recursos: selecione o grupo de recursos demo-cmek-rg que você criou nas etapas anteriores.
- Região: selecione uma região, como Oeste dos EUA.
- Nome: insira o nome da sua identidade gerenciada atribuída pelo usuário, como, por exemplo, demokeyvaultmi.
- Selecione Examinar + criar.
- Depois que a mensagem Validação Aprovada for exibida, selecione Criar.
Após uma implantação bem-sucedida, selecione Ir para o recurso.
Criar atribuições de função
Você precisa criar duas atribuições de função para o cofre de chaves. Para obter mais detalhes, confira 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 desencapsular chaves.
- Vá para o seu cofre de chaves demo-cmek-keyvault.
- Selecione IAM (Controle de acesso) .
- Selecione Adicionar>Adicionar atribuição de função.
- Atribua a seguinte função:
- Função: Usuário do Serviço de Criptografia de Cofre de Chaves
- Atribuir acesso a: Identidade Gerenciada
- Membro: demokeyvaultmi
- Selecione Revisar + atribuir e visualize suas configurações.
- Selecione Examinar + atribuir para criar a atribuição de função.
Criar uma atribuição de função para a sua conta
Crie uma 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: Responsável pela Criptografia do Cofre de Chaves
- Atribuir acesso a: usuário, grupo ou entidade de serviço
- Membro: sua conta do Microsoft Entra
- Selecione Revisar + atribuir e visualize suas configurações.
- Selecione Examinar + atribuir para criar a atribuição de função.
Você pode verificar as atribuições de função do cofre de chaves no Controle de acesso (IAM)>Atribuições de função.
Criar uma chave
Você precisa criar uma chave que o seu cofre de chaves usará para criptografar uma conta de armazenamento.
- Vá para o seu cofre de chaves demo-cmek-keyvault.
- Selecione Chaves.
- Selecione Gerar/Importar.
- Na página Criar uma chave, selecione os valores a seguir:
- Opções: Gerar
- Nome: demo-cmek-key
- Aceite as configurações padrão para as outras opções.
- Selecione Criar.
Anote o nome da chave. Você irá usá-lo quando implantar 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 busca, insira Identidades gerenciadas.
- Em Serviços, selecione Identidades Gerenciadas.
- Selecione Criar.
- Assinatura: Selecione sua assinatura.
- Grupo de recursos: selecione o grupo de recursos demo-cmek-rg.
- Região: selecione uma região, como Oeste dos EUA.
- Nome: insira o nome da sua identidade gerenciada atribuída pelo usuário, como, por exemplo, demomanagedappmi.
- Selecione Examinar + criar.
- Depois que a mensagem Validação Aprovada for exibida, selecione Criar.
Após uma implantação bem-sucedida, selecione Ir para o recurso.
Atribuir permissão de função à identidade gerenciada
Atribua a função Operador de Identidade Gerenciada à identidade gerenciada dentro do escopo da identidade gerenciada atribuída pelo usuário chamada demokeyvaultmi.
- Acesse a identidade gerenciada atribuída pelo usuário chamada demokeyvaultmi.
- Selecione Controle de Acesso (IAM).
- Selecione Adicionar>Adicionar atribuição de função para abrir a página Adicionar atribuição de função.
- Atribua a função a seguir.
- Função: Operador de Identidade Gerenciada
- Atribuir acesso à: Identidade Gerenciada
- Membro: demomanagedappmi
- Selecione Revisar + atribuir e visualize suas configurações.
- Selecione Examinar + atribuir para criar a atribuição de função.
Você pode verificar a atribuição de função a demokeyvaultmi no Controle de acesso (IAM)>Atribuições de função.
Amostra de modelo de aplicativo gerenciado
Crie um aplicativo gerenciado que implanta uma conta de armazenamento em um grupo de recursos gerenciados e use uma chave de um cofre de chaves já existente para criptografar os dados na conta de armazenamento.
Para publicar um aplicativo gerenciado no catálogo de serviços, execute as seguintes tarefas:
- Crie o arquivo creatUIDefinition.json da amostra incluída neste artigo. O modelo define os elementos da interface do usuário do portal ao implantar o aplicativo gerenciado.
- Crie um modelo no Azure Resource Manager chamado mainTemplate.json convertendo o arquivo Bicep incluído neste artigo em 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 no catálogo de serviços. Para obter mais informações, vá para Início Rápido: criar e publicar uma definição de Aplicativo Gerenciado do Azure.
Criar o modelo createUiDefinition.json
O modelo a seguir cria uma identidade gerenciada atribuída pelo usuário para o aplicativo gerenciado. Nesse exemplo, desabilitamos a identidade gerenciada atribuída pelo sistema porque precisamos que a nossa identidade gerenciada atribuída pelo usuário seja configurada com antecedência com as permissões do Operador de Identidade Gerenciada para 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.
- Salve o arquivo.
{
"$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 o modelo mainTemplate.json
O arquivo Bicep a seguir é o código-fonte do 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.
- Salve o arquivo.
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 compilar o arquivo mainTemplate.json . Vá para o diretório no qual você salvou seu arquivo Bicep e execute o comando build.
bicep build mainTemplate.bicep
Após o arquivo Bicep ter sido convertido em JSON, seu arquivo mainTemplate.json deverá corresponder ao exemplo a seguir. Você poderá ter valores diferentes nas propriedades de metadata para 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)]"
}
}
}
}
]
}
Implantar o aplicativo gerenciado
Após a definição do catálogo de serviços ter sido criada, você poderá implantar o aplicativo gerenciado. Para obter mais informações, vá para Início Rápido: implantar um aplicativo gerenciado do catálogo de serviços.
Durante a implantação, você usará suas identidades gerenciadas atribuídas pelo usuário, o nome do cofre de chaves, o URL do cofre de chaves e o nome da chave do cofre de chaves. O arquivo createUiDefinition.json cria a interface do usuário.
Por exemplo, em uma implantação do 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 implantação
Após a implantação ter sido concluída, 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 no qual você implantou o aplicativo gerenciado.
- Em Configurações>Identidade selecione Atribuída pelo usuário (versão prévia).
Você também pode verificar a conta de armazenamento que o aplicativo gerenciado implantou. A guia Criptografia mostra a chave demo-cmek-key e a ID do recurso para a identidade gerenciada atribuída pelo usuário.
- Vá para o grupo de recursos gerenciados no qual a conta de armazenamento do aplicativo gerenciado estiver implantada.
- Em Segurança + Rede, selecione Criptografia.
Próximas etapas
- Para obter mais informações sobre criptografia de armazenamento, vá para Chaves gerenciadas pelo cliente para a 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.