Compartilhar via

Usar Bicep para gerenciar segredos

  • 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

É possível evitar o uso de segredos em muitas situações. Muitos recursos do Azure habilitam identidades gerenciadas para autenticar e serem autorizados a acessar outros recursos no Azure sem que você precise lidar ou gerenciar qualquer credencial. Além disso, alguns serviços do Azure podem gerar certificados HTTPS automaticamente, poupando você de lidar com 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 em log 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 disponibilizá-lo para o autor da chamada ou para outros recursos, considere uma das seguintes abordagens.

Procurar segredos dinamicamente

Às vezes, é necessário acessar um segredo de um recurso para configurar outro. 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 do Azure Functions. Você pode usar a palavra-chave existing para obter uma referência fortemente tipada à conta de armazenamento pré-criada e, em seguida, usar o método listKeys() da conta de armazenamento para criar uma cadeia de conexão com a chave primária.

O exemplo a seguir faz parte de um exemplo maior. Para ver um arquivo Bicep que você pode implantar, consulte 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'
  }
}

Seguir essa abordagem pode ajudar você a evitar passar segredos para dentro ou para fora do arquivo Bicep e também 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 usar o Bicep para criar e gerenciar cofres e segredos. 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 de terceiros, talvez seja necessário adicioná-los manualmente ao cofre antes de referenciá-los 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 do parâmetro mySecret do módulo é definido em um key vault chamado contosonetworkingsecrets, que está 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.

Referencie o cofre de chaves 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 a versão do segredo; a última versão será usada se você não fornecer.

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

As práticas recomendadas a seguir podem ajudar você a lidar com seus segredos com cautela ao usar um pipeline para implantar seus recursos do Azure:

  • Evite armazenar segredos no repositório de código. Por exemplo, não adicione segredos a arquivos de parâmetros ou a 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.