Observação
O acesso a essa página exige autorização. Você pode tentar entrar ou alterar diretórios.
O acesso a essa página exige autorização. Você pode tentar alterar os diretórios.
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 dão 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 você especifica uma chave gerenciada pelo cliente, essa chave é usada para proteger e controlar o acesso à chave que criptografa seus dados. As 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ê não tiver uma conta, crie uma conta gratuita antes de começar.
- Visual Studio Code com a extensão mais recente do Azure Resource Manager Tools. 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.
- Familiarize-se com como criar e implantar uma definição de catálogo de serviços.
Identidades gerenciadas
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, acesse o 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 aplicativo e será removida se este 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, criptografada com chaves de cliente de um cofre de chaves existente, é necessário mais configuração. 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, acesse a função Operador de Identidade Gerenciada.
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 inicial, selecione Criar um recurso.
- Na caixa de pesquisa, insira Key Vault.
- Na lista de resultados, selecione Key Vault.
- Na seção Key Vault , selecione Criar.
- Na seção Create Key Vault, forneça as seguintes informações:
- Assinatura: selecione sua assinatura.
- 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.
- Tipo de preço: selecione Padrão na lista suspensa.
- Proteção contra eliminação: selecione Ativar proteção contra eliminação.
- Selecione Avançar e vá para a guia Política de Acesso .
- Configuração de acesso: selecione o controle de acesso baseado em função do Azure.
- Aceite os padrões 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 , anote as seguintes propriedades:
- Nome do cofre: no exemplo, o nome do cofre é demo-keyvault-cmek. Você usará este nome em 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 Contribuidor da Identidade Gerenciada.
- Na caixa de pesquisa, insira identidades gerenciadas.
- Em Serviços, selecione Identidades Gerenciadas.
- Selecione Criar e insira os seguintes valores na guia Básico :
- 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 Leste dos EUA.
- Nome: insira o nome da identidade gerenciada atribuída pelo usuário, como demokeyvaultmi.
- Selecione Examinar + criar.
- Após Validação Concluída ser 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 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 desencapsular chaves.
- Vá para o cofre de chaves demo-cmek-keyvault.
- Selecione Controle de acesso (IAM) .
- Selecione Adicionar>Adicionar atribuição de função.
- Atribua a seguinte função:
- Função: Usuário de Criptografia do Serviço de Chaves do Key Vault
- Atribuir acesso a: identidade gerenciada
- Membro: demokeyvaultmi
- Selecione Examinar + atribuir para exibir suas configurações.
- Selecione Examinar + atribuir para criar a atribuição de função.
Criar uma atribuição de função para 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: sua conta do Microsoft Entra
- Selecione Examinar + atribuir para exibir 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 em Controle de acesso (IAM)>Atribuições de função.
Criar uma chave
Você precisa criar uma chave que o cofre de chaves usa para criptografar uma conta de armazenamento.
- Vá para o cofre de chaves, 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, 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 Leste dos EUA.
- Nome: insira o nome da identidade gerenciada atribuída pelo usuário, como demomanagedappmi.
- Selecione Examinar + criar.
- Após Validação Concluída ser 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 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 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 a: Identidade Gerenciada
- Membro: demomanagedappmi
- Selecione Examinar + atribuir para exibir suas configurações.
- Selecione Examinar + 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.
Modelo de aplicativo gerenciado de exemplo
Crie um aplicativo gerenciado que implanta 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 no catálogo de serviços, execute as seguintes tarefas:
- Crie o arquivo creatUIDefinition.json 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 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 do aplicativo gerenciado para que ela esteja disponível no catálogo de serviços. Para obter mais informações, acesse Introdução: 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 pelo sistema porque precisamos que nossa identidade gerenciada atribuída pelo usuário seja configurada com antecedência 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.
- 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 modelo mainTemplate.json
O arquivo Bicep a seguir é o código-fonte do 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 criar o arquivo mainTemplate.json . Vá para o diretório em que você salvou o arquivo Bicep e execute o build comando.
bicep build mainTemplate.bicep
Depois que o arquivo Bicep for convertido em JSON, seu arquivo mainTemplate.json deverá corresponder ao exemplo a seguir. Você pode ter valores diferentes nas metadata propriedades 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
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 o 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 de uso.
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 a URL do cofre de chaves e o nome da chave que você criou.
Verificar a implantação
Depois que a implantação for 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 Usuário atribuído (versão prévia).
Você também pode verificar a conta de armazenamento que o aplicativo gerenciado implantou. A aba Criptografia mostra a chave demo-cmek-key e a ID do recurso específico para a identidade gerenciada atribuída pelo usuário.
- Vá para o grupo de recursos gerenciados em que a conta de armazenamento do aplicativo gerenciado é implantada.
- Em Segurança + rede , selecione Criptografia.
Próximas etapas
- Para obter mais informações sobre criptografia de armazenamento, acesse 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, acesse Configurar chaves gerenciadas pelo cliente no mesmo locatário para uma conta de armazenamento existente.