Compartilhar via

Gerenciar segredos usando o Bicep

  • Artigo

As implantações geralmente exigem que os segredos sejam armazenados e propagados com segurança em todo o ambiente do Azure. O Bicep e o Azure fornecem muitos recursos para ajudá-lo a gerenciar segredos em suas implantações.

Evitar segredos onde você pode

Em muitas situações, é possível evitar completamente o uso de segredos. Muitos recursos do Azure suportam identidades gerenciadas, que permitem autenticar e serem autorizados a acessar outros recursos no Azure, sem a necessidade de manipular ou gerenciar credenciais. Além disso, alguns serviços do Azure podem gerar certificados HTTPS automaticamente, evitando que você trate de certificados e chaves privadas. Use identidades gerenciadas e certificados gerenciados pelo serviço sempre que possível.

Use parâmetros seguros

Quando você precisar fornecer segredos para suas implantações do Bicep como parâmetros, use o @secure() decorador. Quando você marca um parâmetro como seguro, o Azure Resource Manager evita registrar o valor ou exibi-lo no portal do Azure, na CLI do Azure ou no Azure PowerShell.

Evitar saídas para segredos

Não use saídas Bicep para dados seguros. As saídas são registradas no histórico de implantação e qualquer pessoa com acesso à implantação pode exibir os valores das saídas de uma implantação.

Se você precisar gerar um segredo em uma implantação do Bicep e torná-lo disponível para o chamador ou para outros recursos, considere usar uma das seguintes abordagens.

Procurar segredos dinamicamente

Às vezes, você precisa acessar um segredo de um recurso para configurar outro recurso.

Por exemplo, você pode ter criado uma conta de armazenamento em outra implantação e precisa acessar sua chave primária para configurar um aplicativo no Azure Functions. Você pode usar a palavra-chave existing para obter uma referência fortemente digitada à conta de armazenamento pré-criada e, em seguida, usar o método da conta de armazenamento listKeys() para criar uma cadeia de conexão com a chave primária:

O exemplo a seguir faz parte de um exemplo maior. Para obter um arquivo Bicep que você pode implantar, confira o arquivo completo.

param location string = resourceGroup().location
param storageAccountName string
param functionAppName string = 'fn-${uniqueString(resourceGroup().id)}'

var appServicePlanName = 'MyPlan'
var applicationInsightsName = 'MyApplicationInsights'

resource storageAccount 'Microsoft.Storage/storageAccounts@2021-06-01' existing = {
  name: storageAccountName
}

var storageAccountConnectionString = 'DefaultEndpointsProtocol=https;AccountName=${storageAccount.name};EndpointSuffix=${environment().suffixes.storage};AccountKey=${listKeys(storageAccount.id, storageAccount.apiVersion).keys[0].value}'

resource functionApp 'Microsoft.Web/sites@2023-12-01' = {
  name: functionAppName
  location: location
  kind: 'functionapp'
  properties: {
    httpsOnly: true
    serverFarmId: appServicePlan.id
    siteConfig: {
      appSettings: [
        {
          name: 'APPINSIGHTS_INSTRUMENTATIONKEY'
          value: applicationInsights.properties.InstrumentationKey
        }
        {
          name: 'AzureWebJobsStorage'
          value: storageAccountConnectionString
        }
        {
          name: 'FUNCTIONS_EXTENSION_VERSION'
          value: '~3'
        }
        {
          name: 'FUNCTIONS_WORKER_RUNTIME'
          value: 'dotnet'
        }
        {
          name: 'WEBSITE_CONTENTAZUREFILECONNECTIONSTRING'
          value: storageAccountConnectionString
        }
      ]
    }
  }
}

resource appServicePlan 'Microsoft.Web/serverfarms@2023-12-01' = {
  name: appServicePlanName
  location: location
  sku: {
    name: 'Y1' 
    tier: 'Dynamic'
  }
}

resource applicationInsights 'Microsoft.Insights/components@2020-02-02' = {
  name: applicationInsightsName
  location: location
  kind: 'web'
  properties: { 
    Application_Type: 'web'
    publicNetworkAccessForIngestion: 'Enabled'
    publicNetworkAccessForQuery: 'Enabled'
  }
}

Usando essa abordagem, você evita passar segredos para ou do arquivo Bicep.

Você também pode usar essa abordagem para armazenar segredos em um cofre de chaves.

Usar o Cofre de Chaves

O Azure Key Vault foi projetado para armazenar e gerenciar dados seguros. Use um cofre de chaves para gerenciar seus segredos, certificados, chaves e outros dados que precisam ser protegidos e compartilhados.

Você pode criar e gerenciar cofres e segredos usando o Bicep. Defina seus cofres criando um recurso com o tipo Microsoft.KeyVault/vaults.

Ao criar um cofre, você precisa determinar quem e o que pode acessar seus dados. Se você planeja ler os segredos do cofre de dentro de um arquivo Bicep, defina a propriedade enabledForTemplateDeployment como true.

Adicionar segredos a um cofre de chaves

Os segredos são um recurso filho e podem ser criados usando o tipo Microsoft.KeyVault/vaults/secrets. O exemplo a seguir demonstra como criar um cofre e um segredo:

O exemplo a seguir faz parte de um exemplo maior. Para obter um arquivo Bicep que você pode implantar, confira o arquivo completo.

param location string = resourceGroup().location
param keyVaultName string = 'mykv${uniqueString(resourceGroup().id)}'

resource keyVault 'Microsoft.KeyVault/vaults@2023-07-01' = {
  name: keyVaultName
  location: location
  properties: {
    enabledForTemplateDeployment: true
    tenantId: tenant().tenantId
    accessPolicies: [
    ]
    sku: {
      name: 'standard'
      family: 'A'
    }
  }
}

resource keyVaultSecret 'Microsoft.KeyVault/vaults/secrets@2023-07-01' = {
  parent: keyVault
  name: 'MySecretName'
  properties: {
    value: 'MyVerySecretValue'
  }
}

Dica

Quando você usa pipelines de implantação automatizados, às vezes pode ser um desafio determinar como inicializar segredos do cofre de chaves para suas implantações. Por exemplo, se foi fornecido a você uma chave de API para ser usada ao se comunicar com uma API externa, o segredo precisará ser adicionado a um cofre antes que ele possa ser usado em suas implantações.

Quando você trabalha com segredos que vêm de terceiros, talvez seja necessário adicioná-los manualmente ao seu cofre e, em seguida, fazer referência ao segredo para todos os usos subsequentes.

Usar um cofre de chaves com módulos

Ao usar módulos Bicep, você pode fornecer parâmetros seguros usando a getSecret função.

Você também pode fazer referência a um cofre de chaves definido em outro grupo de recursos usando as palavras-chave existing e scope juntas. No exemplo a seguir, o arquivo Bicep é implantado em um grupo de recursos chamado Rede. O valor para o parâmetro do módulo mySecret é definido em um cofre de chaves chamado contosonetworkingsecrets localizado no grupo de recursos Segredos:

resource networkingSecretsKeyVault 'Microsoft.KeyVault/vaults@2023-07-01' existing = {
  scope: resourceGroup('Secrets')
  name: 'contosonetworkingsecrets'
}

module exampleModule 'module.bicep' = {
  name: 'exampleModule'
  params: {
    mySecret: networkingSecretsKeyVault.getSecret('mySecret')
  }
}

Usar um cofre de chaves em um arquivo .bicepparam

Ao usar o formato de arquivo, .bicepparam, você pode fornecer valores seguros para parâmetros seguros usando a getSecretfunção.

Faça referência ao KeyVault fornecendo a ID da assinatura, o nome do grupo de recursos e o nome do cofre de chaves. Você pode obter o valor do segredo fornecendo o nome do segredo. Opcionalmente, você pode fornecer uma versão do segredo. Se você não fornecer a versão secreta, a versão mais recente será usada.

using './main.bicep'

param secureUserName = az.getSecret('<subscriptionId>', '<resourceGroupName>', '<keyVaultName>', '<secretName>', '<secretVersion>')
param securePassword = az.getSecret('<subscriptionId>', '<resourceGroupName>', '<keyVaultName>', '<secretName>')

Trabalhar com segredos em pipelines

Ao implantar seus recursos do Azure usando um pipeline, você precisa ter cuidado para lidar com seus segredos adequadamente.

  • Evite armazenar segredos no repositório de código. Por exemplo, não adicione segredos aos arquivos de parâmetros ou aos arquivos YAML de definição de pipeline.
  • No GitHub Actions, use segredos criptografados para armazenar dados seguros. Usar a verificação secreta para detectar confirmações acidentais de segredos.
  • No Azure Pipelines, use variáveis secretas para armazenar dados seguros.