A függvényalkalmazás erőforrás-üzembe helyezésének automatizálása a Azure Functions

A függvényalkalmazás üzembe helyezésének automatizálásához használjon Bicep-fájlt vagy Egy Azure Resource Manager-sablont (ARM-sablont). Az üzembe helyezés során használhatja a meglévő Azure-erőforrásokat, vagy létrehozhat újakat.

Az üzembe helyezési automatizálás, az infrastruktúra kódként (IaC) és a folyamatos integráció és üzembe helyezés (CI/CD) használatával élvezheti ezeknek az előnyöknek a hatását az éles alkalmazásoknál.

  • Konzisztencia: Az infrastruktúra kódban való definiálása a környezetek konzisztens üzembe helyezésének biztosítása érdekében.
  • Verziókövetés: Az infrastruktúra és az alkalmazáskonfigurációk változásainak nyomon követése a forrásvezérlőben a projektkóddal együtt.
  • Automatizálás: Automatizálja az üzembe helyezést, amely csökkenti a manuális hibákat, és lerövidíti a kiadási folyamatot.
  • Méretezhetőség: Egyszerűen replikálhatja az infrastruktúrát több környezethez, például fejlesztéshez, teszteléshez, valamint élesítéshez.
  • Vészhelyreállítás: Gyorsan hozza létre újra az infrastruktúrát hibák vagy migrálások után.

Ez a cikk bemutatja, hogyan automatizálhatja Azure erőforrások és üzembe helyezési konfigurációk létrehozását Azure Functions. A projektkód folyamatos üzembe helyezéséről további információt a Folyamatos üzembe helyezés Azure Functions című szakaszban található.

A szükséges Azure erőforrások létrehozásához szükséges sablonkód a függvényalkalmazás kívánt üzemeltetési beállításaitól függ. Ez a cikk a következő üzemeltetési lehetőségeket támogatja:

Üzemeltetési lehetőség Üzembe helyezés típusa Példasablonok
Rugalmas fogyasztási csomag Code-only Bicep
ARM-sablon
Terraform
Prémium csomag Kód | Konténer Bicep
ARM-sablon
Dedikált terv Kód | Konténer Bicep
ARM-sablon
Azure Konténer Alkalmazások Container-only Bicep
Fogyasztási terv(régi) Code-only Bicep
ARM-sablon

Új kiszolgáló nélküli függvényalkalmazások esetén használja a Flex Consumption csomagot.
A Használati csomag egy régi üzemeltetési csomag. Meglévő alkalmazások esetén migráljon a Flex Consumption csomagba.

Ügyeljen arra, hogy a cikk tetején válassza ki az üzemeltetési tervet.

Important

A függvényalkalmazások, amelyek a használaton kívüli v3 futtatókörnyezetet futtatják Linuxon egy használatalapú csomagban, 2026. szeptember 30-a után leállnak. A szolgáltatáskimaradás elkerülése érdekében migrálja az alkalmazást a v4-futtatókörnyezetbe.

2028. szeptember 30-án megszüntetik a lehetőséget, hogy függvényalkalmazásokat üzemeltetjen Linuxon egy Fogyasztási tervben. A Linux-használat csomag nem kap új funkciókat vagy nyelvi verziókat. A használati tervben Windows-on futó alkalmazásokra jelenleg nincs hatással. Migrálja az alkalmazásokat a Rugalmas használat csomagba a kivonási dátum előtt.

A cikk használatakor tartsa szem előtt az alábbi szempontokat:

  • A példák egyes erőforrások egyes szakaszaiként jelennek meg.

Szükséges erőforrások

Ezeket az erőforrásokat létre kell hoznia vagy konfigurálnia kell egy Azure Functions üzemeltetéshez:

Resource Requirement Szintaxis és tulajdonságok referenciája
Tárhelyfiók Required Microsoft. Storage/StorageAccounts
Application Insights-összetevő Recommended Microsoft. Elemzések/összetevők*
Üzemeltetési terv Required Microsoft. Web-/kiszolgálófarmok
Függvényalkalmazás Required Microsoft.Web/sites

Ezeket az erőforrásokat létre kell hoznia vagy konfigurálnia kell egy Azure Functions üzemeltetéshez:

Resource Requirement Szintaxis és tulajdonságok referenciája
Tárhelyfiók Required Microsoft. Storage/StorageAccounts
Application Insights-összetevő Recommended Microsoft. Elemzések/összetevők*
Függvényalkalmazás Required Microsoft.Web/sites

Az Azure Container Apps-ban üzemeltetett kiépítés általában a következő erőforrásokból áll:

Resource Requirement Szintaxis és tulajdonságok referenciája
Tárhelyfiók Required Microsoft. Storage/StorageAccounts
Application Insights-összetevő Recommended Microsoft. Elemzések/összetevők*
Felügyelt környezet Required Microsoft.App/managedEnvironments
Függvényalkalmazás Required Microsoft.Web/sites

*Ha még nincs olyan Log Analytics-munkaterülete, amelyet az Application Insights-példány használhat, akkor ezt az erőforrást is létre kell hoznia.

Ha több erőforrást helyez üzembe egyetlen Bicep fájlban vagy ARM-sablonban, fontos az erőforrások létrehozásának sorrendje. Ez a követelmény az erőforrások közötti függőségekből ered. Ilyen függőségek esetén mindenképpen használja a dependsOn elemet a függőség meghatározására a függő erőforrásban. További információ: Az erőforrások ARM-sablonokban való üzembe helyezésének sorrendjének megadása vagy Erőforrás-függőségek Bicep.

Prerequisites

  • Ezek a példák egy meglévő erőforráscsoport kontextusában működnek.
  • Az Application Insightshoz és a tárolási naplókhoz is szükség van egy meglévő Azure Log Analytics-munkaterületre. A munkaterületeket megoszthatja a szolgáltatások között. A teljesítmény javítása érdekében hozzon létre egy munkaterületet minden földrajzi régióban. A Log Analytics munkaterület létrehozásának módjáról a Log Analytics munkaterület létrehozása című témakörben talál példát. A teljes munkaterület erőforrás-azonosítóját az Azure Portal munkaterületoldalán, a Beállítások>tulajdonságai>erőforrás-azonosító területén találja.
  • Ez a cikk feltételezi, hogy már létrehozott egy felügyelt környezetet az Azure Container Appsben. A Container Appsben üzemeltetett függvényalkalmazás létrehozásához szüksége van a felügyelt környezet nevére és azonosítójára is.

Storage-fiók létrehozása

Minden függvényalkalmazáshoz Azure tárfiók szükséges. Olyan általános célú fiókra van szüksége, amely támogatja a blobokat, táblákat, üzenetsorokat és fájlokat. További információ: Azure Functions tárfiókra vonatkozó követelmények.

Important

A tárfiók fontos alkalmazásadatok tárolására szolgál, néha magában az alkalmazáskódban is. Korlátoznia kell a hozzáférést más alkalmazásoktól és felhasználóktól a tárfiókhoz.

Ez a példaszakasz létrehoz egy standard általános célú v2-tárfiókot:

resource storageAccount 'Microsoft.Storage/storageAccounts@2023-05-01' = {
  name: storageAccountName
  location: location
  kind: 'StorageV2'
  sku: {
    name: 'Standard_LRS'
  }
  properties: {
    supportsHttpsTrafficOnly: true
    defaultToOAuthAuthentication: true
    allowBlobPublicAccess: false
    minimumTlsVersion: 'TLS1_2'
  }
}

További információt a main.bicep fájlban talál a sablonok adattárában.

További információt a mintaadattár teljes storage-PrivateEndpoint.bicep fájljában talál.

A függvényalkalmazásnak csatlakoznia kell ehhez a tárfiókhoz. Konfigurálja ezt a kapcsolatot a AzureWebJobsStorage beállítással. További információ: Alkalmazáskonfiguráció.

Tip

A nagyobb biztonság érdekében adja hozzá a allowSharedKeyAccess: false-t a tárfiók tulajdonságaihoz, és használjon felügyelt identitásalapú kapcsolatokat a kapcsolati sztringek helyett. A jelen cikkben szereplő Flex Consumption-csomag példái ezt a megközelítést használják, beleértve az AzureWebJobsStorage__* identitásalapú beállításokat és a rendszer által hozzárendelt felügyelt identitást. További információért lásd: Csatlakozás gazdagéptárolóhoz identitással.

Tip

A nagyobb biztonság érdekében állítsa be a tárolási fiókot allowSharedKeyAccessfalse-ra, és használjon felügyelt identitásalapú kapcsolatokat a kapcsolati sztringek helyett. További információért lásd: Csatlakozás gazdagéptárolóhoz identitással.

Important

Az Elastic Premium és Consumption csomagok az Azure Filest használják a tartalommegosztáshoz, és az Azure Files jelenleg nem támogatja a felügyelt identitásalapú kapcsolatokat. Ez a korlátozás azt jelenti, hogy ezek a tervek megosztott kulcshoz való hozzáférést igényelnek a tárfiókhoz, ezért ne állítsa be allowSharedKeyAccess értékét false-re. Ha kapcsolati sztringeket kell használnia, tárolja őket az Azure Key Vaultban, és a kulcsok közvetlen tárolása helyett használja a Key Vault-hivatkozásokat az alkalmazás beállításai között. Ha el szeretné távolítani az Azure Files-függőséget, olvassa el az Alkalmazás létrehozása Azure Files nélkül című témakört.

Telepítési tároló

A Flex Consumption-csomagban futó alkalmazások üzembe helyezéséhez üzembe helyezési forrásként egy Azure Blob Storage-tárolóra van szükség. Használhatja az alapértelmezett tárfiókot, vagy megadhat egy külön tárfiókot. További információ: Üzembehelyezési beállítások konfigurálása.

Az alkalmazás létrehozásakor konfigurálnia kell ezt az üzembehelyezési fiókot, beleértve az üzembe helyezéshez használt tárolót is. A telepítések konfigurálásáról további információt a telepítési források című témakörben olvashat.

Ez a példa bemutatja, hogyan hozhat létre tárolót a tárfiókban:

}

// Azure Functions Flex Consumption
module functionApp 'br/public:avm/res/web/site:0.16.0' = {
  name: 'functionapp'
  scope: rg
  params: {
    kind: 'functionapp,linux'
    name: functionAppName_resolved
    location: location
    tags: union(tags, { 'azd-service-name': 'api' })
    serverFarmResourceId: appServicePlan.outputs.resourceId
    managedIdentities: {
      systemAssigned: true
    }
    functionAppConfig: {
      deployment: {
        storage: {
          type: 'blobContainer'
          value: '${storage.outputs.primaryBlobEndpoint}${deploymentStorageContainerName}'
          authentication: {
            type: 'SystemAssignedIdentity'
          }

Ez a példa bemutatja, hogyan használható a AVM tárfiókokhoz a blobtároló és a tárfiók létrehozásához. A kódrészlet kontextusban történő megtekintéséhez kérlek, lásd ez az üzembehelyezési példa.

Konfiguráljon más üzembehelyezési beállításokat magával az alkalmazással.

Tárolási naplók engedélyezése

Mivel a tárfiókot a függvényalkalmazás fontos adataihoz használják, figyelje a fiókot a tartalom módosításához. A tárfiók figyeléséhez konfigurálja az Azure Monitor-erőforrásnaplókat az Azure Storage-hoz. Ebben a példában egy Log Analytics myLogAnalytics nevű munkaterület lesz a naplók célhelye.

resource blobService 'Microsoft.Storage/storageAccounts/blobServices@2023-05-01' existing = {
  name:'default'
  parent:storageAccountName
}

resource storageDataPlaneLogs 'Microsoft.Insights/diagnosticSettings@2021-05-01-preview' = {
  name: '${storageAccountName}-logs'
  scope: blobService
  properties: {
    workspaceId: myLogAnalytics.id
    logs: [
      {
        category: 'StorageWrite'
        enabled: true
      }
    ]
    metrics: [
      {
        category: 'Transaction'
        enabled: true
      }
    ]
  }
}

Ugyanazt a munkaterületet használhatja a később definiált Application Insights-erőforráshoz. További információ, beleértve a naplók kezelését, lásd: Monitoring Azure Storage.

Application Insights létrehozása

Az Application Insights használatával figyelheti a függvényalkalmazások végrehajtását. Az Application Insights most már Azure Log Analytics munkaterületet igényel, amely megosztható. Ezek a példák feltételezik, hogy egy meglévő munkaterületet használ, és rendelkezik a munkaterület teljes erőforrás-azonosítójával. További információ: Azure Log Analytics munkaterület.

Ebben a példarészben definiálja az Application Insights erőforrást a Microsoft.Insights/components típussal és a web kategóriával.

resource applicationInsight 'Microsoft.Insights/components@2020-02-02' = {
  name: applicationInsightsName
  location: appInsightsLocation
  tags: tags
  kind: 'web'
  properties: {
    Application_Type: 'web'
    WorkspaceResourceId: '<FULLY_QUALIFIED_RESOURCE_ID>'
  }
}

További információt a main.bicep fájlban talál a sablonok adattárában.

Az alkalmazásbeállítás használatával meg kell adnia a kapcsolatot a APPLICATIONINSIGHTS_CONNECTION_STRING függvényalkalmazással. További információ: Alkalmazáskonfiguráció.

A cikkben szereplő példák lekérik a létrehozott példány kapcsolati sztring értékét. A régebbi verziók esetleg APPINSIGHTS_INSTRUMENTATIONKEY használhatják az instrumentációs kulcs beállítására, ami már nem ajánlott.

Az üzemeltetési terv létrehozása

Explicit módon meg kell határoznia az Azure Functions Flex-használati csomagban, prémium csomagban vagy dedikált (App Service-) csomagban üzemeltetett alkalmazások üzemeltetési csomagját.

A Flex Consumption egy Linux-alapú üzemeltetési terv, amely a használatalapú fizetésre épül a kiszolgáló nélküli számlázási modell alapján. A csomag támogatja a privát hálózatkezelést, a példány memóriaméretének kiválasztását és a felügyelt identitások továbbfejlesztett támogatását.

A Rugalmas fogyasztási terv egy speciális serverfarm erőforrástípus. A FC1 segítségével megadhatja a Name tulajdonság értékét a sku tulajdonságban, ha a tier értéke FlexConsumption.

Ez a példaszakasz létrehoz egy Rugalmas Felhasználási tervet:

  scaleAndConcurrency: {
    maximumInstanceCount: maximumInstanceCount
    instanceMemoryMB: instanceMemoryMB
  }
  runtime: { 
    name: functionAppRuntime
    version: functionAppRuntimeVersion
  }
}
siteConfig: {
  alwaysOn: false
}
configs: [{
  name: 'appsettings'
  properties:{

Ez a példa az App Service-csomagokhoz használt AVM. A kódrészlet kontextusban történő megtekintéséhez kérlek, lásd ez az üzembehelyezési példa.

Mivel a Flex Consumption csomag jelenleg csak a Linuxot támogatja, be kell állítania a reserved tulajdonságot true értékre.

A Prémium csomag ugyanazt a skálázást kínálja, mint a Használati csomag, de dedikált erőforrásokat és további képességeket is tartalmaz. További információ: Azure Functions Prémium csomag.

A Prémium csomag egy speciális erőforrástípus serverfarm . Meghatározhatja a EP1 tulajdonság értékét, ha a EP2 tulajdonságnál a EP3, a Name vagy a sku értéket használja. A Functions üzemeltetési csomag meghatározásának módja attól függ, hogy a függvényalkalmazás Windows vagy Linux rendszeren fut-e. Ez a példaszakasz létrehoz egy EP1 tervet:

resource hostingPlan 'Microsoft.Web/serverfarms@2024-04-01' = {
  name: hostingPlanName
  location: location
  sku: {
    name: 'EP1'
    tier: 'ElasticPremium'
    family: 'EP'
  }
  kind: 'elastic'
  properties: {
    maximumElasticWorkerCount: 20
  }
}

További információt a main.bicep fájlban talál a sablonok adattárában.

Az objektummal kapcsolatos további információkért sku tekintse meg SkuDefinition vagy tekintse át a példasablonokat.

A Dedikált (App Service) csomagban a függvényalkalmazás dedikált virtuális gépeken fut az App Service-csomagokban az Alapszintű, a Standard és a Prémium termékváltozatokban, hasonlóan a webalkalmazásokhoz. További információ: Dedikált csomag.

A Bicep fájl/Azure Resource Manager sablon mintájáért tekintse meg a funkciós alkalmazást Azure App Service terven.

A Functionsben a dedikált csomag csak egy normál App Service-csomag, amelyet egy serverfarm erőforrás határoz meg. Legalább az name értéket meg kell adnia. A támogatott tervnevek listáját a --sku dedikált terv támogatott értékeinek aktuális listájában az appservice plan create találja.

Az üzemeltetési terv meghatározásának módja attól függ, hogy a függvényalkalmazás Windows vagy Linux rendszeren fut-e:

resource hostingPlanName 'Microsoft.Web/serverfarms@2024-04-01' = {
  name: hostingPlanName
  location: location
  sku: {
    tier: 'Standard'
    name: 'S1'
    size: 'S1'
    family: 'S'
    capacity: 1
  }
}

További információt a main.bicep fájlban talál a sablonok adattárában.

Az üzemeltetési terv létrehozása

Nem kell kifejezetten meghatároznia egy fogyasztási tárhelyterv erőforrást. Ha kihagyja ezt az erőforrásdefiníciót, a portál automatikusan létrehoz vagy kiválaszt egy régiónkénti csomagot, amikor magát a függvényalkalmazás-erőforrást hozza létre.

A használati terveket külön erőforrástípusként serverfarm definiálhatja. Állítsa be a computeMode és sku tulajdonságokat Dynamic értékre. Ez a példaszakasz bemutatja, hogyan definiálhat explicit módon használati tervet. Az üzemeltetési terv meghatározásának módja attól függ, hogy a függvényalkalmazás Windows vagy Linux rendszeren fut-e.

resource hostingPlan 'Microsoft.Web/serverfarms@2024-04-01' = {
  name: hostingPlanName
  location: location
  sku: {
    name: 'Y1'
    tier: 'Dynamic'
    size: 'Y1'
    family: 'Y'
    capacity: 0
  }
  properties: {
    computeMode: 'Dynamic'
  }
}

További információt a main.bicep fájlban talál a sablonok adattárában.

A függvényalkalmazás létrehozása

Adja meg a függvényalkalmazás erőforrását egy olyan típusú Microsoft.Web/sites erőforrásként, amely tartalmaz egy kind tulajdonságot.functionapp

A függvényalkalmazás-erőforrás definiálásának módja attól függ, hogy Linuxon vagy Windowson üzemel-e:

A Windows való futtatáshoz szükséges alkalmazásbeállítások listáját a Alkalmazás konfigurációja című témakörben találja. A Minta Bicep-fájl vagy az Azure Resource Manager-sablon megtekintéséhez tekintse meg a Windowsban üzemeltetett függvényalkalmazást egy használati tervsablonban .

A Windows való futtatáshoz szükséges alkalmazásbeállítások listáját a Alkalmazás konfigurációja című témakörben találja.

A Flex Consumption a Bicep- és ARM-sablontelepítésekben használt standard alkalmazásbeállításokat és webhely-konfigurációs tulajdonságokat váltja fel. További információ: Alkalmazáskonfiguráció.

        AzureWebJobsStorage__blobServiceUri: 'https://${storage.outputs.name}.blob.${environment().suffixes.storage}'
        AzureWebJobsStorage__queueServiceUri: 'https://${storage.outputs.name}.queue.${environment().suffixes.storage}'
        AzureWebJobsStorage__tableServiceUri: 'https://${storage.outputs.name}.table.${environment().suffixes.storage}'

        // Application Insights settings are always included
        APPLICATIONINSIGHTS_CONNECTION_STRING: applicationInsights.outputs.connectionString
        APPLICATIONINSIGHTS_AUTHENTICATION_STRING: 'Authorization=AAD'
    }
    }]
  }
}

// Consolidated Role Assignments
module rbacAssignments 'rbac.bicep' = {
  name: 'rbacAssignments'
  scope: rg
  params: {
    storageAccountName: storage.outputs.name
    appInsightsName: applicationInsights.outputs.name
    managedIdentityPrincipalId: functionApp.outputs.?systemAssignedMIPrincipalId ?? ''
    userIdentityPrincipalId: principalId
    allowUserIdentityPrincipal: !empty(principalId)
  }
}

// Outputs
output AZURE_LOCATION string = location
output AZURE_TENANT_ID string = tenant().tenantId
output AZURE_FUNCTION_NAME string = functionApp.outputs.name
output APPLICATIONINSIGHTS_CONNECTION_STRING string = applicationInsights.outputs.connectionString

Ez a példa a AVM függvényalkalmazásokhoz használható. A kódrészlet kontextusban történő megtekintéséhez kérlek, lásd ez az üzembehelyezési példa.

Note

Ha úgy dönt, hogy opcionálisan meghatározza a Használati tervet, be kell állítania az alkalmazás serverFarmId tulajdonságát úgy, hogy az a terv erőforrás-azonosítójára mutasson. Győződjön meg arról, hogy a függvényalkalmazás rendelkezik olyan dependsOn beállítással, amely a tervre is hivatkozik. Ha nem definiált explicit módon egy tervet, létrejön egy ön számára.

Állítsa be az serverFarmId alkalmazás tulajdonságát úgy, hogy az a terv erőforrás-azonosítójára mutatjon. Győződjön meg arról, hogy a függvényalkalmazás rendelkezik olyan dependsOn beállítással, amely a tervre is hivatkozik.

resource functionAppName_resource 'Microsoft.Web/sites@2024-04-01' = {
  name: functionAppName
  location: location
  kind: 'functionapp'
  properties: {
    serverFarmId: hostingPlanName.id
    siteConfig: {
      appSettings: [
        {
          name: 'APPLICATIONINSIGHTS_CONNECTION_STRING'
          value: applicationInsightsName.properties.ConnectionString
        }
        {
          name: 'AzureWebJobsStorage'
          value: 'DefaultEndpointsProtocol=https;AccountName=${storageAccountName};EndpointSuffix=${environment().suffixes.storage};AccountKey=${storageAccount.listKeys().keys[0].value}'
        }
        {
          name: 'WEBSITE_CONTENTAZUREFILECONNECTIONSTRING'
          value: 'DefaultEndpointsProtocol=https;AccountName=${storageAccountName};EndpointSuffix=${environment().suffixes.storage};AccountKey=${storageAccount.listKeys().keys[0].value}'
        }
        {
          name: 'WEBSITE_CONTENTSHARE'
          value: toLower(functionAppName)
        }
        {
          name: 'FUNCTIONS_EXTENSION_VERSION'
          value: '~4'
        }
        {
          name: 'FUNCTIONS_WORKER_RUNTIME'
          value: 'node'
        }
        {
          name: 'WEBSITE_NODE_DEFAULT_VERSION'
          value: '~20'
        }
      ]
    }
  }
}

Az elejétől a végéig tartó teljes példa megtalálható itt: main.bicep fájl.

resource functionApp 'Microsoft.Web/sites@2024-04-01' = {
  name: functionAppName
  location: location
  kind: 'functionapp'
  properties: {
    serverFarmId: hostingPlan.id
    siteConfig: {
      alwaysOn: true
      appSettings: [
        {
          name: 'APPLICATIONINSIGHTS_CONNECTION_STRING'
          value: applicationInsightsName.properties.ConnectionString
        }
        {
          name: 'AzureWebJobsStorage'
          value: 'DefaultEndpointsProtocol=https;AccountName=${storageAccountName};EndpointSuffix=${environment().suffixes.storage};AccountKey=${storageAccount.listKeys().keys[0].value}'
        }
        {
          name: 'FUNCTIONS_EXTENSION_VERSION'
          value: '~4'
        }
        {
          name: 'FUNCTIONS_WORKER_RUNTIME'
          value: 'node'
        }
        {
          name: 'WEBSITE_NODE_DEFAULT_VERSION'
          value: '~20'
        }
      ]
    }
  }
}

Az elejétől a végéig tartó teljes példa megtalálható itt: main.bicep fájl.

Üzembehelyezési források

linuxFxVersion A webhelybeállítással igényelhet egy adott Linux-tárolót az alkalmazás üzembe helyezéséhez a létrehozáskor. A privát adattárban lévő képek eléréséhez további beállításokra van szükség. További információ: Alkalmazáskonfiguráció.

Important

Saját tárolók létrehozásakor frissíteni kell a tároló alaprendszerképét a legújabb támogatott alaprendszerképre. A Azure Functions támogatott alaprendszerképei nyelvspecifikusak. Tekintse meg az Azure Functions alaprendszerkép-adattárat.

A Functions csapata elkötelezett amellett, hogy havonta frissítéseket tegyen közzé ezekhez az alapképekhez. A rendszeres frissítések közé tartoznak a legújabb alverziófrissítések és biztonsági javítások mind a Functions-futtatókörnyezethez, mind a nyelvekhez. Rendszeresen frissítenie kell a tárolót a legújabb alaprendszerképről, és újból üzembe kell helyeznie a tároló frissített verzióját. További információ: Egyéni tárolók karbantartása.

A Bicep-fájl vagy AZ ARM-sablon opcionálisan a függvénykód üzembe helyezését is meghatározhatja. Ez az üzembe helyezés a következő módszereket tartalmazhatja:

A Flex Consumption csomag egy zip-tömörített csomagfájlban tartja karban a projektkódot egy üzembehelyezési tárolónak nevezett blobtárolóban. Az üzembe helyezéshez használt tárfiókot és tárolót is konfigurálhatja. További információ: Üzembe helyezés.

A kódcsomag üzembehelyezési tárolóban való közzétételéhez egy központi telepítést kell használnia. Arm-sablon vagy Bicep-telepítés során ezt a lépést a bővítményt használó /onedeploy teheti meg. Ha úgy dönt, hogy közvetlenül feltölti a csomagot a tárolóba, a csomag nem lesz automatikusan üzembe helyezve.

Telepítési tároló

A webhelyhez tartozó propertiesfunctionAppConfig.deployment.storage elemben állítsa be az üzembe helyezéshez használt tárfiókot és tárolót, valamint a hitelesítési módszert és a hitelesítő adatokat. Az alkalmazás létrehozásakor a tárolónak és minden alkalmazásbeállításnak léteznie kell. Példa a tároló létrehozásának módjára: Üzembe helyezési tároló.

Ez a példa egy rendszer által hozzárendelt felügyelt identitást használ a megadott blobtároló eléréséhez, amely az üzembe helyezés más pontján jön létre:

// Consolidated Role Assignments
module rbacAssignments 'rbac.bicep' = {
  name: 'rbacAssignments'
  scope: rg
  params: {
    storageAccountName: storage.outputs.name
    appInsightsName: applicationInsights.outputs.name
    managedIdentityPrincipalId: functionApp.outputs.?systemAssignedMIPrincipalId ?? ''
    userIdentityPrincipalId: principalId
    allowUserIdentityPrincipal: !empty(principalId)
  }
}

// Outputs
output AZURE_LOCATION string = location
output AZURE_TENANT_ID string = tenant().tenantId
output AZURE_FUNCTION_NAME string = functionApp.outputs.name
output APPLICATIONINSIGHTS_CONNECTION_STRING string = applicationInsights.outputs.connectionString

Ez a példa a AVM függvényalkalmazásokhoz használható. A kódrészlet kontextusban történő megtekintéséhez kérlek, lásd ez az üzembehelyezési példa.

Felügyelt identitások használata esetén engedélyeznie kell a függvényalkalmazásnak, hogy az identitás használatával férhessen hozzá a tárfiókhoz, ahogyan az ebben a példában látható:

module storageRoleAssignment_User 'br/public:avm/ptn/authorization/resource-role-assignment:0.1.2' = if (allowUserIdentityPrincipal && !empty(userIdentityPrincipalId)) {
  name: 'storageRoleAssignment-User-${uniqueString(storageAccount.id, userIdentityPrincipalId)}'
  params: {
    resourceId: storageAccount.id
    roleDefinitionId: roleDefinitions.storageBlobDataOwner
    principalId: userIdentityPrincipalId
    principalType: 'User'
    description: 'Storage Blob Data Owner role for user identity (development/testing)'
    roleName: 'Storage Blob Data Owner'
  }
}

Ez a példa a AVM-et használja az erőforrás-hatókörű szerepkör-hozzárendeléshez. A kódrészlet kontextusban történő megtekintéséhez kérlek, lásd ez az üzembehelyezési példa.

Ebben a példában ismernie kell a hozzárendelt szerepkör GUID-értékét. Az azonosítóérték lekéréséhez bármely barátságos szerepkörnév esetén használja az az szerepkör-definíciók listája parancsot, ahogyan az az ebben a példában látható:

az role definition list --output tsv --query "[?roleName=='Storage Blob Data Owner'].{name:name}"

Amikor kapcsolati sztringet használ a felügyelt identitások helyett, állítsa be a(z) authentication.type értékét StorageAccountConnectionString-re, és a(z) authentication.storageAccountConnectionStringName nevét az alkalmazásbeállítás nevére, amely tartalmazza az üzembehelyezési tárfiók kapcsolati sztringet.

Üzembehelyezési csomag

A Flex Consumption csomag egyetlen üzembe helyezést használ a kódprojekt üzembe helyezéséhez. Maga a kódcsomag ugyanaz, mint a zip-alapú üzembe helyezéshez használt csomag más Functions-üzemeltetési csomagokban. A csomagfájl nevének azonban meg kell lennie released-package.zip.

Ha egyetlen üzembehelyezési csomagot szeretne belefoglalni a sablonba, használja az /onedeploy erőforrásdefiníciót a központi telepítési csomagot tartalmazó távoli URL-címhez. A Functions-gazdagépnek hozzá kell tudnia férni ehhez a távoli csomagforráshoz és az üzembehelyezési tárolóhoz is.

Ez a példa egy üzembe helyezési forrást ad hozzá egy meglévő alkalmazáshoz:

@description('The name of the function app.')
param functionAppName string

@description('The location into which the resources should be deployed.')
param location string = resourceGroup().location

@description('The zip content URL for released-package.zip.')
param packageUri string

resource functionAppName_OneDeploy 'Microsoft.Web/sites/extensions@2022-09-01' = {
  name: '${functionAppName}/onedeploy'
  location: location
  properties: {
    packageUri: packageUri
    remoteBuild: false 
  }
}

A Bicep-fájl vagy AZ ARM-sablon opcionálisan egy zip-alapú üzembe helyezési csomag használatával is meghatározhatja a függvénykód üzembe helyezését.

Ahhoz, hogy sikeresen üzembe helyezhesse az alkalmazást az Azure Resource Manager használatával, ismernie kell az erőforrások Azure-ban való üzembe helyezésének módját. A legtöbb példában a legfelső szintű konfigurációkat a siteConfig használatával alkalmazza. Állítsa be ezeket a konfigurációkat a legfelső szintre, mert információkat továbbít a Functions futtatókörnyezetének és üzembehelyezési motorjának. Az üzembe helyezési rendszernek a legfelső szintű információkra van szüksége, mielőtt alkalmazná az alárendelt sourcecontrols/web erőforrást. Bár ezeket a beállításokat a gyermekszintű config/appSettings erőforrásban konfigurálhatja, bizonyos esetekben a függvényalkalmazást üzembe kell helyezni az alkalmazás alkalmazása előttconfig/appSettings .

Zip üzembehelyezési csomag

A zip-alapú üzembe helyezés a függvényalkalmazás kódjának üzembe helyezésének ajánlott módja. Alapértelmezés szerint a zip-alapú üzembe helyezést használó függvények magukban az üzembe helyezési csomagban futnak. További információkért, beleértve az üzembehelyezési csomagra vonatkozó követelményeket, lásd: Zip üzembe helyezés Azure Functions. Erőforrás-üzembe helyezés automatizálása esetén hivatkozhat a .zip központi telepítési csomagra a Bicep vagy ARM-sablonban.

Ha zip-alapú üzembe helyezést szeretne használni a sablonban, állítsa be a WEBSITE_RUN_FROM_PACKAGE beállítást az alkalmazásban 1 , és adja meg az erőforrásdefiníciót /zipDeploy .

Linux-alapú használat alapú terv esetén ehelyett állítsa be az üzembehelyezési csomag URI-ját közvetlenül a WEBSITE_RUN_FROM_PACKAGE beállításban, ahogy ez a példa sablonban látható.

Ez a példa egy zip-alapú üzembehelyezési forrást ad hozzá egy meglévő alkalmazáshoz:

@description('The name of the function app.')
param functionAppName string

@description('The location into which the resources should be deployed.')
param location string = resourceGroup().location

@description('The zip content url.')
param packageUri string

resource functionAppName_ZipDeploy 'Microsoft.Web/sites/extensions@2024-04-01' = {
  name: '${functionAppName}/ZipDeploy'
  location: location
  properties: {
    packageUri: packageUri
  }
}

Tartsa szem előtt a következő szempontokat, amikor zip-alapú üzembehelyezési erőforrásokat is beleszámítja a sablonba:

  • A packageUri helynek olyan helynek kell lennie, amelyhez a Functions hozzáférhet. Fontolja meg az Azure Blob Storage közös hozzáférésű jogosultságkód (SAS) használatát. Az SAS lejárta után a Functions (Funkciók) már nem tudja elérni a megosztást a telepítésekhez. Az SAS újragenerálásakor ne felejtse el frissíteni a WEBSITE_RUN_FROM_PACKAGE beállítást az új URI-értékkel.

  • URI beállításakor WEBSITE_RUN_FROM_PACKAGE manuálisan kell szinkronizálnia az eseményindítókat.

  • A beállítások hozzáadásakor vagy frissítésekor mindig adja meg a appSettings gyűjtemény összes szükséges alkalmazásbeállítását. A frissítés eltávolítja a nem explicit módon beállított meglévő beállításokat. További információ: Alkalmazáskonfiguráció.

  • A Functions nem támogatja a webes üzembe helyezést (msdeploy) a csomagtelepítésekhez. Ehelyett zip telepítést kell használnia a telepítési folyamatokban és az automatizálásban. További információ: Zip deployment for Azure Functions.

Távoli összeállítások

Az üzembe helyezési folyamat feltételezi, hogy a használt .zip fájl vagy egy zip-telepítés egy használatra kész alkalmazást tartalmaz. Ez a feltételezés azt jelenti, hogy alapértelmezés szerint nem futnak testreszabások.

Bizonyos esetekben távolról kell újraépítenie az alkalmazást. Ilyen például, ha Linux-specifikus csomagokat kell tartalmaznia a Pythonban, vagy Node.js windowsos számítógépen fejlesztett alkalmazásokat. Ebben az esetben úgy konfigurálhatja a Functionst, hogy távoli buildet hajtson végre a kódon a zip üzembe helyezése után.

A távoli build kérésének módja attól függ, hogy milyen operációs rendszert helyez üzembe:

Amikor alkalmazást helyez üzembe a Windows rendszerben, az üzembe helyezési folyamat nyelvspecifikus parancsokat futtat, például dotnet restore C#-alkalmazásokhoz vagy npm install Node.js-alkalmazásokhoz.

A folyamatos integrációval elérhető ugyanolyan buildelési folyamatok engedélyezéséhez adja hozzá a SCM_DO_BUILD_DURING_DEPLOYMENT=true az alkalmazásbeállításai közé az üzembehelyezési kódban, és teljesen távolítsa el a WEBSITE_RUN_FROM_PACKAGE beállítást.

Linux-tárolók

Ha kontainerizált függvényalkalmazást helyez üzembe egy Azure Functions Prémium vagy Dedikált csomagban, a következőket kell tennie:

Ha bizonyos beállítások hiányoznak, az alkalmazás kiépítése sikertelen lehet ezzel a HTTP/500-hibával:

Function app provisioning failed.

További információ: Alkalmazáskonfiguráció.

resource functionApp 'Microsoft.Web/sites@2024-04-01' = {
  name: functionAppName
  location: location
  kind: 'functionapp'
  properties: {
    serverFarmId: hostingPlan.id
    siteConfig: {
      appSettings: [
        {
          name: 'AzureWebJobsStorage'
          value: 'DefaultEndpointsProtocol=https;AccountName=${storageAccountName};AccountKey=${storageAccount.listKeys().keys[0].value}'
        }
        {
          name: 'FUNCTIONS_WORKER_RUNTIME'
          value: 'node'
        }
        {
          name: 'WEBSITE_NODE_DEFAULT_VERSION'
          value: '~20'
        }
        {
          name: 'FUNCTIONS_EXTENSION_VERSION'
          value: '~4'
        }
        {
          name: 'DOCKER_REGISTRY_SERVER_URL'
          value: dockerRegistryUrl
        }
        {
          name: 'DOCKER_REGISTRY_SERVER_USERNAME'
          value: dockerRegistryUsername
        }
        {
          name: 'DOCKER_REGISTRY_SERVER_PASSWORD'
          value: dockerRegistryPassword
        }
        {
          name: 'WEBSITES_ENABLE_APP_SERVICE_STORAGE'
          value: 'false'
        }
      ]
      linuxFxVersion: 'DOCKER|myacr.azurecr.io/myimage:mytag'
    }
  }
  dependsOn: [
    storageAccount
  ]
}

A kontainerizált függvények Azure Container Apps üzembe helyezésekor a sablonnak a következőket kell tennie:

  • Állítsa a kind mezőt a következő értékre functionapp,linux,container,azurecontainerapps: .
  • Állítsa be a managedEnvironmentId webhely tulajdonságát a Container Apps környezet teljesen minősített URI-jára.
  • Adjon hozzá erőforráshivatkozást a webhely dependsOn gyűjteményéhez, amikor Microsoft.App/managedEnvironments erőforrást hoz létre a webhellyel egy időben.

A privát tárolóregisztrációs adatbázisból egy meglévő Container Apps-környezetbe üzembe helyezett tárolóalapú függvényalkalmazás definíciója az alábbi példához hasonlóan nézhet ki:

resource functionApp 'Microsoft.Web/sites@2024-04-01' = {
  name: functionAppName
  kind: 'functionapp,linux,container,azurecontainerapps'
  location: location
  properties: {
    serverFarmId: hostingPlanName
    siteConfig: {
      linuxFxVersion: 'DOCKER|myacr.azurecr.io/myimage:mytag'
      appSettings: [
        {
          name: 'FUNCTIONS_EXTENSION_VERSION'
          value: '~4'
        }
        {
          name: 'AzureWebJobsStorage'
          value: 'DefaultEndpointsProtocol=https;AccountName=${storageAccountName};AccountKey=${storageAccount.listKeys().keys[0].value}'
        }
        {
          name: 'APPLICATIONINSIGHTS_CONNECTION_STRING'
          value: applicationInsightsName.properties.ConnectionString
        }
      ]
    }
    managedEnvironmentId: managedEnvironmentId
  }
  dependsOn: [
    storageAccount
    hostingPlan
  ]
}

Alkalmazáskonfiguráció

A Rugalmas fogyasztási csomagban az Azure-ban a függvényalkalmazást kétféle tulajdonsággal konfigurálhatja.

Configuration Microsoft.Web/sites tulajdonság
Alkalmazáskonfiguráció functionAppConfig
Alkalmazásbeállítások siteConfig.appSettings gyűjtemény

Ezeket az alkalmazáskonfigurációkat a következő helyen functionAppConfigtarthatja fenn:

Behavior A következő beállítások: functionAppConfig
Mindig kész példányok scaleAndConcurrency.alwaysReady
Üzembehelyezési forrás deployment
Példány mérete scaleAndConcurrency.instanceMemoryMB
HTTP-eseményindító egyidejűsége scaleAndConcurrency.triggers.http.perInstanceConcurrency
Nyelvi futtatókörnyezet runtime.name
Nyelvi verzió runtime.version
Példányok maximális száma scaleAndConcurrency.maximumInstanceCount
Webhelyfrissítési stratégia siteUpdateStrategy.type

A Flex Consumption csomag az alábbi alkalmazásbeállításokat is támogatja:

A Függvények a függvényalkalmazás Azure való konfigurálásához az alábbi lehetőségeket nyújtják:

Configuration Microsoft.Web/sites tulajdonság
Webhely beállításai siteConfig
Alkalmazásbeállítások siteConfig.appSettings gyűjtemény

Ezek a webhelybeállítások szükségesek a siteConfig tulajdonságban:

Ezek a helybeállítások csak felügyelt identitások használata esetén szükségesek a rendszerkép Azure Container Registry-példányból való lekéréséhez:

Ezek az alkalmazásbeállítások szükségesek (vagy ajánlottak) egy adott operációs rendszerhez és üzemeltetési beállításhoz:

Ezek az alkalmazásbeállítások szükségesek a tárolótelepítésekhez:

Ezekre a beállításokra csak privát tárolóregisztrációs adatbázisból való üzembe helyezéskor van szükség:

A webhely- és alkalmazásbeállítások Bicep fájlok vagy ARM-sablonok használatával történő használatakor vegye figyelembe ezeket a szempontokat:

  • Az opcionális alwaysReady beállítás egy vagy több {name,instanceCount} objektumból álló tömböt tartalmaz, és mindegyik függvényskálázási csoporthoz egyet tartalmaz. Ezek a skálázási csoportok mindig kész méretezési döntéseket hoznak. Ez a példa mindig készenléti számokat állít be mind a http csoport számára, mind pedig egyetlen, nem csoportosított eseményindító típusú függvény helloworld esetén.
      alwaysReady: [
    {
      name: 'http'
      instanceCount: 2
    }
    {
      name: 'function:helloworld'
      instanceCount: 1
    }
  ]
  • Fontolja meg, hogy mikor érdemes automatikus üzembe helyezést beállítani WEBSITE_CONTENTSHARE . Részletes útmutatásért tekintse meg a WEBSITE_CONTENTSHARE hivatkozást.

  • Az alkalmazásbeállításokat mindig úgy definiálja, mint a létrehozandó erőforrás siteConfig/appSettings gyűjteményét Microsoft.Web/sites, ahogyan azt az ebben a cikkben bemutatott példákban is láthatja. Ez a definíció garantálja, hogy a függvényalkalmazás futtatásához szükséges beállítások elérhetők legyenek a kezdeti indításkor.

  • Ha sablonokkal adja hozzá vagy frissíti az alkalmazásbeállításokat, győződjön meg arról, hogy az összes meglévő beállítást tartalmazza a frissítéssel. Ezt azért kell megtennie, mert az alapul szolgáló frissítési REST API-hívások felülírják a teljes /config/appsettings erőforrást. Ha eltávolítja a meglévő beállításokat, a függvényalkalmazás nem fog futni. Az egyes alkalmazásbeállítások programozott frissítéséhez ehelyett használhatja a Azure CLI, a Azure PowerShell vagy a Azure portált a módosítások elvégzéséhez. További információ: Az alkalmazásbeállítások használata.

  • Ha lehetséges, használjon felügyelt identitásalapú kapcsolatokat más Azure-szolgáltatásokhoz, beleértve a AzureWebJobsStorage kapcsolatot is. További információ: Identitásalapú kapcsolat konfigurálása.

Slot telepítések

A Functions lehetővé teszi a kód különböző verzióinak üzembe helyezését a függvényalkalmazás egyedi végpontjaira. Ez a beállítás megkönnyíti a függvényfrissítések fejlesztését, érvényesítését és üzembe helyezését anélkül, hogy az hatással lenne az éles környezetben futó függvényekre. Az üzembehelyezési pontok a Azure App Service egyik funkciója. A rendelkezésre álló tárolóhelyek száma az üzemeltetési tervtől függ. További információ: Azure Functions üzembehelyezési pontok.

A ponterőforrást ugyanúgy definiálja, mint egy függvényalkalmazás-erőforrást (Microsoft.Web/sites), de ehelyett az erőforrás-azonosítót Microsoft.Web/sites/slots használja. Egy olyan üzembe helyezési példáért (Bicep és ARM-sablonokban), amely egyszerre hoz létre éles és átmeneti pontot egy Prémium csomagban, tekintse meg a Azure függvényalkalmazást üzembehelyezési ponttal.

A foglalatok sablonok használatával való felcserélésének módjáról további információkért lásd: Automatizálás Resource Manager sablonokkal.

Tartsa szem előtt a következő szempontokat a ponttelepítések használatakor:

  • Ne állítsa be explicit módon a WEBSITE_CONTENTSHARE beállítást az üzembehelyezési hely definíciójában. A telepítési helyen lévő alkalmazáslétrehozási folyamat hozza létre ezt a beállítást.

  • A pontok felcserélésekor egyes alkalmazásbeállítások "ragadósnak" minősülnek, mivel azok a ponttal maradnak, és nem a felcserélt kóddal. Ezt a pontbeállítást úgy határozhatja meg, hogy belefogadja "slotSetting":true a sablon adott alkalmazásbeállítás-definíciójához. További információ: Beállítások kezelése.

Biztonságos telepítések

A függvényalkalmazást olyan üzembe helyezésben hozhatja létre, amelyben virtuális hálózatokkal való integrációval egy vagy több erőforrást biztonságossá tehet. Az Microsoft.Web/sites/networkConfig erőforrás a függvényalkalmazás virtuális hálózati integrációját határozza meg. Ez az integráció a hivatkozott függvényalkalmazástól és a virtuális hálózati erőforrásoktól is függ. A függvényalkalmazás más privát hálózati erőforrásoktól is függhet, például privát végpontoktól és útvonalaktól. További információ: Azure Functions hálózati beállítások.

Ezek a projektek Bicep-alapú példákat nyújtanak a függvényalkalmazások virtuális hálózaton való üzembe helyezésére, beleértve a hálózati hozzáférés korlátozásait is:

Ha biztonságos tárfiókot használó üzembe helyezést hoz létre, explicit módon kell beállítania a WEBSITE_CONTENTSHARE beállítást, és létre kell hoznia a beállításban elnevezett fájlmegosztási erőforrást. Győződjön meg arról, hogy Microsoft.Storage/storageAccounts/fileServices/shares egy erőforrást hoz létre WEBSITE_CONTENTSHARE érték felhasználásával, ahogy azt ebben a példában (ARM-sablon|Bicep-fájl) láthatja. A webhelytulajdonságot vnetContentShareEnabled is igaz értékre kell állítania.

Note

Ha ezek a beállítások nem részei egy biztonságos tárfiókot használó üzembe helyezésnek, a következő hibaüzenet jelenik meg az üzembe helyezés ellenőrzése során: Could not access storage account using provided connection string.

Ezek a projektek Bicep és ARM-sablonokat is kínálnak a függvényalkalmazások virtuális hálózaton való üzembe helyezésére, beleértve a hálózati hozzáférés korlátozásait is:

Korlátozott forgatókönyv Description
Virtuális hálózati integrációval rendelkező függvényalkalmazás létrehozása A függvényalkalmazást egy virtuális hálózatban hozza létre, amely teljes hozzáféréssel rendelkezik az adott hálózat erőforrásaihoz. A függvényalkalmazás bejövő és kimenő hozzáférése nincs korlátozva. További információ: Virtuális hálózat integrációja.
Biztonságos tárfiókhoz hozzáférő függvényalkalmazás létrehozása A létrehozott függvényalkalmazás egy biztonságos tárfiókot használ, amelyet a Functions privát végpontok használatával ér el. További információért lásd: Tárfiók korlátozása virtuális hálózatra.
Privát végpontokat használó függvényalkalmazás és tárfiók létrehozása A létrehozott függvényalkalmazás csak privát végpontokkal érhető el, és privát végpontokat használ a tárolási erőforrások eléréséhez. További információ: Privát végpontok.

Korlátozott hálózati beállítások

Akkor is szükség lehet ezekre a beállításokra, ha a függvényalkalmazás hálózati korlátozásokkal rendelkezik:

Setting Value Description
WEBSITE_CONTENTOVERVNET 1 Alkalmazásbeállítás, amely lehetővé teszi a függvényalkalmazás skálázását, ha a tárfiók virtuális hálózatra van korlátozva. További információért lásd: Tárfiók korlátozása virtuális hálózatra.
vnetrouteallenabled 1 Helybeállítás, amely a függvényalkalmazásból érkező összes forgalmat a virtuális hálózat használatára kényszeríti. További információ: Regionális virtuális hálózat integrációja. Ez a webhelybeállítás felülírja az alkalmazás beállításait WEBSITE_VNET_ROUTE_ALL.

A hálózati korlátozások szempontjai

Ha a privát végpontokon keresztül korlátozza a tárfiókhoz való hozzáférést, a tárfiók nem érhető el a portálon vagy a virtuális hálózaton kívüli eszközökön keresztül. Az alapértelmezett hálózati hozzáférési szabály kezelésével hozzáférést adhat a tárfiók biztonságos IP-címéhez vagy virtuális hálózatához.

Függvényelérési kulcsok

Gazdaszintű függvényelérési kulcsok definiálása Azure-erőforrásokként. Ezzel a módszerrel gazdagépkulcsokat hozhat létre és kezelhet ARM-sablonokban és Bicep-fájlokban. A gazdagépkulcsot Microsoft.Web/sites/host/functionKeys típusú erőforrásként definiáljuk. Az alábbi példa létrehoz egy my_custom_key nevű gazdagépszintű hozzáférési kulcsot, amikor a függvényalkalmazás létrehozásra kerül.

resource functionKey 'Microsoft.Web/sites/host/functionKeys@2022-09-01' = {
  name: '${parameters('name')}/default/my_custom_key'
  properties: {
    name: 'my_custom_key'
  }
  dependsOn: [
    resourceId('Microsoft.Web/Sites', parameters('name'))
  ]
}

Ebben a példában a name paraméter az új függvényalkalmazás neve. Olyan beállítást kell megadnia dependsOn , amely garantálja, hogy a kulcs az új függvényalkalmazással jön létre. Végül a properties gazdagépkulcs objektuma egy value tulajdonságot is tartalmazhat, amellyel beállíthat egy adott kulcsot.

Ha nem állítja be a value tulajdonságot, a Functions automatikusan létrehoz egy új kulcsot az erőforrás létrehozásakor, ami javasolt. A hívóbetűkkel kapcsolatos további információkért, beleértve a hozzáférési kulcsok használatához ajánlott biztonsági eljárásokat, olvassa el a A hívóbetűk használata a Azure Functions webhelyen.

A sablon létrehozása

A Bicep- vagy ARM-sablonokkal rendelkező szakértők egy egyszerű szövegszerkesztő használatával manuálisan kódolhatják a telepítéseket. A többiek számára több lehetőség is megkönnyíti a fejlesztési folyamatot:

  • Visual Studio Code: Bővítmények érhetők el a Bicep-fájlok és az ARM-sablonok használatához. Ezekkel az eszközökkel meggyőződhet arról, hogy a kód helyes. Alapszintű ellenőrzést biztosítanak.

  • Azure portál: Amikor létrehozza a függvényalkalmazást és a kapcsolódó erőforrásokat a portálon, az utolsó Áttekintés + Létrehozás képernyő Sablon letöltése automatizáláshoz hivatkozással rendelkezik.

    Töltse le a sablon hivatkozását az Azure Functions létrehozási folyamatából az Azure portálon.

    Ez a hivatkozás a portálon kiválasztott beállítások alapján létrehozott ARM-sablont mutatja be. Ez a sablon kissé összetettnek tűnhet, amikor sok új erőforrást tartalmazó függvényalkalmazást hoz létre. Ez azonban jó referenciaként szolgálhat az ARM-sablon megjelenéséhez.

A sablon ellenőrzése

Amikor manuálisan hozza létre az üzembehelyezési sablonfájlt, fontos ellenőrizni a sablont az üzembe helyezés előtt. Az összes üzembehelyezési módszer ellenőrzi a sablon szintaxisát, és hibaüzenetet validation failed jelenít meg az alábbi JSON formátumú példában látható módon:

{"error":{"code":"InvalidTemplate","message":"Deployment template validation failed: 'The resource 'Microsoft.Web/sites/func-xyz' is not defined in the template. Please see https://aka.ms/arm-template for usage details.'.","additionalInfo":[{"type":"TemplateViolation","info":{"lineNumber":0,"linePosition":0,"path":""}}]}}

A sablon üzembe helyezése előtt az alábbi módszerekkel ellenőrizheti a sablont:

A következő Azure erőforráscsoport-üzembehelyezési v2 feladatdeploymentMode: 'Validation' utasítja az Azure Pipelines szolgáltatást a sablon érvényesítésére.

- task: AzureResourceManagerTemplateDeployment@3
  inputs:
    deploymentScope: 'Resource Group'
    subscriptionId: # Required subscription ID
    action: 'Create Or Update Resource Group'
    resourceGroupName: # Required resource group name
    location: # Required when action == Create Or Update Resource Group
    templateLocation: 'Linked artifact'
    csmFile: # Required when  TemplateLocation == Linked Artifact
    csmParametersFile: # Optional
    deploymentMode: 'Validation'

Teszterőforrás-csoportot is létrehozhat az előzetes és üzembehelyezési hibák megkereséséhez.

A sablon üzembe helyezése

A Bicep-fájl és -sablon üzembe helyezéséhez használja az alábbi módszerek bármelyikét:

Azure-ba való telepítés gomb

Note

Ez a módszer jelenleg nem támogatja Bicep fájlok üzembe helyezését.

Cserélje le a <url-encoded-path-to-azuredeploy-json> a URL-kódolt verziójára a azuredeploy.json fájl nyers elérési útjának a GitHubban.

Íme egy példa, amely a markdownt használja:

[![Deploy to Azure](https://azuredeploy.net/deploybutton.png)](https://portal.azure.com/#create/Microsoft.Template/uri/<url-encoded-path-to-azuredeploy-json>)

Íme egy példa, amely HTML-t használ:

<a href="https://portal.azure.com/#create/Microsoft.Template/uri/<url-encoded-path-to-azuredeploy-json>" target="_blank"><img src="https://azuredeploy.net/deploybutton.png"></a>

Üzembe helyezés a PowerShell használatával

A következő PowerShell-parancsok létrehoznak egy erőforráscsoportot, és üzembe helyeznek egy Bicep fájlt vagy ARM-sablont, amely létrehoz egy függvényalkalmazást a szükséges erőforrásokkal. A parancsok helyi futtatásához telepítve kell lennie az Azure PowerShellnek . Az Azure-ba való bejelentkezéshez először futtassa a Connect-AzAccount elemet.

# Register Resource Providers if they're not already registered
Register-AzResourceProvider -ProviderNamespace "microsoft.web"
Register-AzResourceProvider -ProviderNamespace "microsoft.storage"

# Create a resource group for the function app
New-AzResourceGroup -Name "MyResourceGroup" -Location 'West Europe'

# Deploy the template
New-AzResourceGroupDeployment -ResourceGroupName "MyResourceGroup" -TemplateFile main.bicep  -Verbose

Az üzembe helyezés teszteléséhez használjon egy ehhez hasonló sablont, amely Windows rendszerben egy fogyasztási terv alapján hoz létre függvényalkalmazást.

Következő lépések

További információ a Azure Functions fejlesztéséről és konfigurálásáról.

  • Last updated on