Dela via

Hantera hemligheter med hjälp av Bicep

  • Artikel

Distributioner kräver ofta att hemligheter lagras och sprids på ett säkert sätt i 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

I många situationer är det möjligt att undvika att använda hemligheter alls. Många Azure-resurser har stöd för hanterade identiteter, vilket gör att de kan autentisera och ha behörighet att komma åt andra resurser i Azure, utan att du behöver hantera eller hantera autentiseringsuppgifter. Dessutom kan vissa Azure-tjänster generera HTTPS-certifikat åt dig automatiskt, så att du inte kan 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 att använda 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 resurs.

Du kan till exempel ha skapat ett lagringskonto i en annan distribution och behöver komma åt 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ördefinierade lagringskontot och sedan använda lagringskontots listKeys() metod för att skapa en anslutningssträng med primärnyckeln:

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

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@2021-02-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
        }
      ]
    }
  }
}

Med den här metoden undviker du att skicka hemligheter till eller ut ur din Bicep-fil.

Du kan också använda den här metoden för att 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 behöver skyddas och delas.

Du kan skapa och hantera valv och hemligheter med hjälp av Bicep. Definiera dina valv genom att skapa en resurs med typen Microsoft.KeyVault/vaults.

När du skapar ett valv måste du avgöra 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.

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

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

Tips

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, och sedan kan du referera till hemligheten 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 i resursgruppen Hemligheter :

resource networkingSecretsKeyVault 'Microsoft.KeyVault/vaults@2019-09-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 KeyVault genom att ange prenumerations-ID, resursgruppsnamn och nyckelvalvsnamn. Du kan hämta värdet för hemligheten genom att ange det hemliga namnet. Du kan också ange den hemliga versionen. Om du inte anger den hemliga versionen används den senaste versionen.

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

När du distribuerar dina Azure-resurser med hjälp av en pipeline måste du vara noga med att hantera dina hemligheter på rätt sätt.

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