Dela via

Använda Bicep för att hantera hemligheter

  • Artikel

Distributioner kräver ofta att hemligheter lagras och sprids på ett säkert sätt i hela Azure-miljön. Bicep och Azure har många funktioner som hjälper dig att hantera hemligheter i dina distributioner.

Undvik hemligheter där du kan

Det är möjligt att undvika att använda hemligheter helt och hållet i många situationer. Många Azure-resurser gör det möjligt för hanterade identiteter att autentisera och ha behörighet att komma åt andra resurser i Azure och utan att du behöver hantera eller hantera några autentiseringsuppgifter. Dessutom kan vissa Azure-tjänster generera HTTPS-certifikat åt dig automatiskt, vilket besparar dig från att hantera certifikat och privata nycklar. Använd hanterade identiteter och tjänsthanterade certifikat där det är möjligt.

Använda säkra parametrar

När du behöver ange hemligheter för dina Bicep-distributioner som parametrar använder du dekoratören@secure(). När du markerar en parameter som säker undviker Azure Resource Manager att logga värdet eller visa det i Azure Portal, Azure CLI eller Azure PowerShell.

Undvik utdata för hemligheter

Använd inte Bicep-utdata för säkra data. Utdata loggas i distributionshistoriken och alla som har åtkomst till distributionen kan visa värdena för en distributions utdata.

Om du behöver generera en hemlighet i en Bicep-distribution och göra den tillgänglig för anroparen eller andra resurser bör du överväga någon av följande metoder.

Slå upp hemligheter dynamiskt

Ibland måste du komma åt en hemlighet från en resurs för att konfigurera en annan. Du kan till exempel ha skapat ett lagringskonto i en annan distribution och behöver åtkomst till dess primära nyckel för att konfigurera en Azure Functions-app. Du kan använda nyckelordet existing för att hämta en starkt skriven referens till det förskapade lagringskontot och sedan använda lagringskontots listKeys() metod för att skapa en anslutningssträng med den primära nyckeln.

Följande exempel är en del av ett större exempel. En Bicep-fil som du kan distribuera finns i den fullständiga filen.

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'
  }
}

Med den här metoden kan du undvika att skicka hemligheter till eller från din Bicep-fil och även lagra hemligheter i ett nyckelvalv.

Använda Key Vault

Azure Key Vault är utformat för att lagra och hantera säkra data. Använd ett nyckelvalv för att hantera hemligheter, certifikat, nycklar och andra data som måste skyddas och delas.

Du kan använda Bicep för att skapa och hantera valv och hemligheter. Definiera dina valv genom att skapa en resurs med typen Microsoft.KeyVault/vaults.

När du skapar ett valv måste du ta reda på vem och vad som kan komma åt dess data. Om du planerar att läsa valvets hemligheter inifrån en Bicep-fil anger du enabledForTemplateDeployment egenskapen till true.

Lägga till hemligheter i ett nyckelvalv

Hemligheter är en underordnad resurs och kan skapas med hjälp av typen Microsoft.KeyVault/vaults/secrets. I följande exempel visas hur du skapar ett valv och en hemlighet.

Följande exempel är en del av ett större exempel. En Bicep-fil som du kan distribuera finns i den fullständiga filen.

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'
  }
}

Dricks

När du använder automatiserade distributionspipelines kan det ibland vara svårt att avgöra hur du ska starta nyckelvalvshemligheter för dina distributioner. Om du till exempel har fått en API-nyckel som ska användas när du kommunicerar med ett externt API måste hemligheten läggas till i ett valv innan den kan användas i dina distributioner.

När du arbetar med hemligheter som kommer från en tredje part kan du behöva lägga till dem manuellt i valvet innan du kan referera till dem för alla efterföljande användningsområden.

Använda ett nyckelvalv med moduler

När du använder Bicep-moduler kan du ange säkra parametrar med hjälp getSecret av funktionen.

Du kan också referera till ett nyckelvalv som definierats i en annan resursgrupp med hjälp av nyckelorden existing och scope tillsammans. I följande exempel distribueras Bicep-filen till en resursgrupp med namnet Nätverk. Värdet för modulens parameter mySecret definieras i ett nyckelvalv med namnet contosonetworkingsecrets, som finns i resursgruppen Hemligheter:

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')
  }
}

Använda ett nyckelvalv i en .bicepparam-fil

När du använder .bicepparam filformat kan du ange säkra värden för parametrar med hjälp getSecret av funktionen .

Referera till nyckelvalvet genom att ange prenumerations-ID, resursgruppsnamn och nyckelvalvsnamn. Du kan hämta hemlighetens värde genom att ange det hemliga namnet. Du kan också ange den hemliga versionen. den senaste versionen används om du inte gör det.

using './main.bicep'

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

Arbeta med hemligheter i pipelines

Följande metodtips kan hjälpa dig att hantera dina hemligheter med försiktighet när du använder en pipeline för att distribuera dina Azure-resurser:

  • Undvik att lagra hemligheter i din kodlagringsplats. Lägg till exempel inte till hemligheter i parameterfiler eller till YAML-filer för pipelinedefinition.
  • I GitHub Actions använder du krypterade hemligheter för att lagra säkra data. Använd hemlig genomsökning för att identifiera eventuella oavsiktliga incheckningar av hemligheter.
  • I Azure Pipelines använder du hemliga variabler för att lagra säkra data.