Megosztás a következőn keresztül:

Erőforrás-üzembe helyezés automatizálása a függvényalkalmazáshoz az Azure Functionsben

A függvényalkalmazás üzembe helyezésének folyamatát Bicep-fájl vagy Azure Resource Manager-sablon (ARM) használatával automatizálhatja. Az üzembe helyezés során használhatja a meglévő Azure-erőforrásokat, vagy létrehozhat újakat.

Ezeket az előnyöket az éles alkalmazásokban az üzembe helyezés automatizálásával, az infrastruktúra mint kód (IaC) és a folyamatos integráció és üzembe helyezés (CI/CD) használatával érheti el:

  • 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 az Azure-erőforrások és az Azure Functions üzembe helyezési konfigurációinak létrehozását. A projektkód folyamatos üzembe helyezéséről további információt az Azure Functions folyamatos üzembe helyezését ismertető cikkben talál.

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 kihasználtságú 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
Használati terv Code-only Bicep
ARM-sablon

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

Important

2028. szeptember 30. után megszűnik az a lehetőség, hogy a függvényalkalmazást Linuxon üzemeltetje egy használatalapú csomagban. A fennakadások elkerülése érdekében migrálja a Linuxon futó meglévő használatterv-alkalmazásokat a Flex Consumption csomagba az adott dátum előtt. Ez a változás nem érinti a Windows rendszeren futó alkalmazásokat a használatalapú csomagban. További információért tekintse meg a Linux fogyasztási terv megszüntetéséről szóló értesítést.

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

  • Az ARM-sablonokat nem lehet felépíteni.

  • A Bicep-üzembe helyezés modularizálható több Bicep-fájlba és Azure Verified Modules (AVM) formátumba.

  • Ez a cikk feltételezi, hogy alapszintű ismerete van Bicep-fájlok létrehozásához vagy Azure Resource Manager-sablonok létrehozásához.

  • A példák egyes erőforrások egyes szakaszaiként jelennek meg. A teljes Bicep-fájl- és ARM-sablonpéldák széles halmazát az alábbi függvényalkalmazás-üzembehelyezési példákban tekinti meg.
  • A példák egyes erőforrások egyes szakaszaiként jelennek meg. A Bicep esetében az Azure Verified Modules (AVM) jelenik meg, ha elérhető. A teljes Bicep-fájl- és ARM-sablonpéldák széles halmazát az alábbi Flex Consumption-alkalmazástelepítési példákban tekintheti meg.
  • 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 által üzemeltetett üzembe helyezéshez:

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

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

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

Az Azure Container Apps által üzemeltetett üzemelő példányok általában az alábbi erőforrásokból állnak:

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

Az Azure Arc által üzemeltetett üzemelő példányok általában az alábbi erőforrásokból állnak:

Resource Requirement Szintaxis és tulajdonságok referenciája
Tárhelyfiók Required Microsoft.Storage/storageAccounts
Application Insights-összetevő Recommended Microsoft.Insights/components1
App Service Kubernetes-környezet Required Microsoft.ExtendedLocation/customLocations
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égek eredménye. Ilyen függőségek esetén mindenképpen használja az elemet a dependsOn függőség meghatározására a függő erőforrásban. További információ: Az erőforrások ARM-sablonokban vagy erőforrásfüggőségekben való üzembe helyezésének sorrendje a Bicepben.

Prerequisites

  • A példák egy meglévő erőforráscsoport kontextusában való végrehajtására szolgálnak.
  • Az Application Insights és a tárolási naplók használatához egy meglévő Azure Log Analytics-munkaterületre van szükség. A munkaterületek megoszthatók a szolgáltatások között, és általában minden földrajzi régióban létre kell hoznia egy munkaterületet a teljesítmény javítása érdekében. A Log Analytics-munkaterületek 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ó alatt 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 Storage-fió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 Storage-fiókkö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
  }
}

További információkért tekintse meg a teljes main.bicep fájlt a sablonok adattárában.

További információért tekintse meg a teljes storage-PrivateEndpoint.bicep fájlt a mintaadattárban.

Ennek a tárfióknak a kapcsolati sztring kell beállítania alkalmazásbeállításként, amelyet a AzureWebJobsStorage Functions igényel. A cikkben szereplő sablonok ezt a kapcsolati sztring értéket a létrehozott tárfiók alapján hozzák létre, ami ajánlott eljárás. További információ: Alkalmazáskonfiguráció.

Telepítési tároló

A Flex Consumption-csomagban futó alkalmazások üzembe helyezéséhez üzembe helyezési forrásként az Azure Blob Storage-ban található tároló szükséges. 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.

Ezt az üzembehelyezési fiókot már konfigurálni kell az alkalmazás létrehozásakor, 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:

module storage 'br/public:avm/res/storage/storage-account:0.25.0' = {
  name: 'storage'
  scope: rg
  params: {
    name: !empty(storageAccountName) ? storageAccountName : '${abbrs.storageStorageAccounts}${resourceToken}'
    allowBlobPublicAccess: false
    allowSharedKeyAccess: false // Disable local authentication methods as per policy
    dnsEndpointType: 'Standard'
    publicNetworkAccess: 'Enabled'
    networkAcls: {
      defaultAction: 'Allow'
      bypass: 'AzureServices'
    }
    blobServices: {
      containers: [{name: deploymentStorageContainerName}]
    }
    tableServices:{}
    queueServices: {}
    minimumTlsVersion: 'TLS1_2'  // Enforcing TLS 1.2 for better security
    location: location
    tags: tags
  }
}

Ez a példa bemutatja, hogyan használható az AVM a tárfiókokhoz a blobtároló és a tárfiók létrehozásához. A kódrészlet kontextusában lásd ezt az üzembe helyezési példát.

Az egyéb üzembehelyezési beállításokat maga az alkalmazás konfigurálja.

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

Mivel a tárfiókot a függvényalkalmazás fontos adataihoz használják, figyelnie kell a fiókot a tartalom módosításához. A tárfiók figyeléséhez konfigurálnia kell az Azure Monitor-erőforrásnaplókat az Azure Storage-hoz. Ebben a példában a naplók célhelyeként egy log Analytics-munkaterületet myLogAnalytics használunk.

resource blobService 'Microsoft.Storage/storageAccounts/blobServices@2021-09-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
      }
    ]
  }
}

Ugyanez a munkaterület használható később definiált Application Insights-erőforráshoz is. További információkért, beleértve a naplók kezelését, tekintse meg az Azure Storage monitorozását.

Application Insights létrehozása

A függvényalkalmazások végrehajtásának figyeléséhez az Application Insightst kell használnia. Az Application Insightshoz most már szükség van egy Azure Log Analytics-munkaterületre, 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éldában az Application Insights-erőforrás a következő típussal Microsoft.Insights/components és típussal webvan definiálva:

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ókért tekintse meg a teljes main.bicep fájlt a sablonok adattárában.

A kapcsolatot az alkalmazásbeállítással kell megadni a APPLICATIONINSIGHTS_CONNECTION_STRING függvényalkalmazásnak. További információ: Alkalmazáskonfiguráció.

A cikkben szereplő példák beolvasják a létrehozott példány kapcsolati sztring értékét. A régebbi verziók ehelyett a rendszerállapot-kulcs beállítására használhatók APPINSIGHTS_INSTRUMENTATIONKEY , ami már nem ajánlott.

Az üzemeltetési terv létrehozása

Az Azure Functions Flex-használati csomagban, prémium csomagban vagy dedikált (App Service-) csomagban üzemeltetett alkalmazásoknak explicit módon kell meghatározniuk az üzemeltetési tervet.

A Rugalmas használat egy Linux-alapú üzemeltetési csomag, amely a kiszolgáló nélküli számlázási modell használatáért a használatalapú fizetésre épül. 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 kihasználtságú csomag egy speciális erőforrástípus serverfarm . Megadhatja a tulajdonság tulajdonságértékének a FC1Name következő értékévelsku: .tier>FlexConsumption

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

module appServicePlan 'br/public:avm/res/web/serverfarm:0.1.1' = {
  name: 'appserviceplan'
  scope: rg
  params: {
    name: !empty(functionPlanName) ? functionPlanName : '${abbrs.webServerFarms}${resourceToken}'
    sku: {
      name: 'FC1'
      tier: 'FlexConsumption'
    }
    reserved: true
    location: location
    tags: tags
    zoneRedundant: zoneRedundant
  }
}

Ez a példa az App Service-csomagokhoz készült AVM-et használja. A kódrészlet kontextusában lásd ezt az üzembe helyezési példát.

Mivel a Flex Consumption csomag jelenleg csak a Linuxot támogatja, a tulajdonságot is be kell állítaniareserved.true

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 Premium-csomag.

A Prémium csomag egy speciális erőforrástípus serverfarm . Megadhatja a tulajdonságot a tulajdonságban lévő tulajdonság értékével EP1 vagy EP2EP3 használatávalNamesku. A Functions üzemeltetési csomag meghatározásának módja attól függ, hogy a függvényalkalmazás Windowson vagy Linuxon fut-e. Ez a példaszakasz létrehoz egy EP1 tervet:

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

További információkért tekintse meg a teljes main.bicep fájlt 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ű, Standard és Prémium termékváltozatokon, a webalkalmazásokhoz hasonlóan. További információ: Dedikált csomag.

Egy minta Bicep-fájl/Azure Resource Manager-sablonért tekintse meg Azure-alkalmazás Szolgáltatáscsomag függvényalkalmazását.

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 Windowson vagy Linuxon fut-e:

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

További információkért tekintse meg a teljes main.bicep fájlt a sablonok adattárában.

Az üzemeltetési terv létrehozása

Nem kell explicit módon definiálnia egy használati üzemeltetési terv erőforrását. Ha kihagyja ezt az erőforrásdefiníciót, a rendszer automatikusan létrehoz vagy kijelöl egy csomagot régiónként, amikor maga a függvényalkalmazás-erőforrást hozza létre.

A használati terveket explicit módon definiálhatja egy speciális erőforrástípuskéntserverfarm, amelyet a tulajdonságok és Dynamic a computeMode tulajdonságok értékével sku adhat meg. 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 Windowson vagy Linuxon fut-e.

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

További információkért tekintse meg a teljes main.bicep fájlt a sablonok adattárában.

Kubernetes-környezet

Az Azure Functions kódprojektként vagy tárolóalapú függvényalkalmazásként is üzembe helyezhető az Azure Arc-kompatibilis Kubernetesben .

Az alkalmazás létrehozásához és az erőforrások megtervezéséhez már létre kell hoznia egy App Service Kubernetes-környezetet egy Azure Arc-kompatibilis Kubernetes-fürthöz. A cikkben szereplő példák feltételezik, hogy rendelkezik annak az egyéni helynek (customLocationId) és App Service Kubernetes-környezetnek (kubeEnvironmentId) az erőforrás-azonosítójával, amelyre üzembe helyezve van, és amely ebben a példában van beállítva:

param kubeEnvironmentId string
param customLocationId string

Mind a helyeknek, mind a terveknek egy extendedLocation mezőn keresztül kell hivatkoznia az egyéni helyre. Ahogy az ebben a csonkolt példában is látható, extendedLocation a következőhöz tartozó társként propertieskindkívül helyezkedik locationel:

resource hostingPlan 'Microsoft.Web/serverfarms@2022-03-01' = {
  ...
  {
    extendedLocation: {
      name: customLocationId
    }
  }
}

A terverőforrásnak a Kubernetes (K1) értékét SKUkell használnia, a kind mezőnek linux,kubernetesés a reserved tulajdonságnak kell lennie true, mivel linuxos telepítésről van szó. Az egyéni helyazonosítót és extendedLocation a Kubernetes-környezetazonosítót is be kell állítaniakubeEnvironmentProfile.id, amely a következő példaszakaszhoz hasonlóan nézhet ki:

resource hostingPlan 'Microsoft.Web/serverfarms@2022-03-01' = {
  name: hostingPlanName
  location: location
  kind: 'linux,kubernetes'
  sku: {
    name: 'K1'
    tier: 'Kubernetes'
  }
  extendedLocation: {
    name: customLocationId
  }
  properties: {
    kubeEnvironmentProfile: {
      id: kubeEnvironmentId
    }
    reserved: true
  }
}

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

A függvényalkalmazás erőforrását egy olyan típusú Microsoft.Web/siteskind erőforrás határozza meg, amely legalább a függvényalkalmazást is magában foglalja 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 rendszeren való futtatáshoz szükséges alkalmazásbeállítások listáját az Alkalmazáskonfiguráció című témakörben találja. Egy Minta Bicep-fájl/Azure Resource Manager-sablonért tekintse meg a Windowsban üzemeltetett függvényalkalmazást egy használati tervsablonban .

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

A Rugalmas használat a Bicep- és ARM-sablontelepítésekben használt általános alkalmazásbeállításokat és helykonfigurációs tulajdonságokat váltja fel. További információ: Alkalmazáskonfiguráció.

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'
          }
        }
      }
      scaleAndConcurrency: {
        maximumInstanceCount: maximumInstanceCount
        instanceMemoryMB: instanceMemoryMB
      }
      runtime: { 
        name: functionAppRuntime
        version: functionAppRuntimeVersion
      }
    }
    siteConfig: {
      alwaysOn: false
    }
    configs: [{
      name: 'appsettings'
      properties:{
        // Only include required credential settings unconditionally
        AzureWebJobsStorage__credential: 'managedidentity'
        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'
    }
    }]
  }
}

Ez a példa az AVM függvényalkalmazásokat használ. A kódrészlet kontextusában lásd ezt az üzembe helyezési példát.

Note

Ha úgy dönt, hogy opcionálisan definiálja a Használati csomagot, akkor be kell állítania a serverFarmId tulajdonságot az alkalmazásban, 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. 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@2022-03-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: '~14'
        }
      ]
    }
  }
}

A teljes körű példaért tekintse meg ezt a main.bicep fájlt.

resource functionApp 'Microsoft.Web/sites@2022-03-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: '~14'
        }
      ]
    }
  }
}

A teljes körű példaért tekintse meg ezt a main.bicep fájlt.

Üzembehelyezési források

A webhelybeállítással linuxFxVersion kérheti egy adott Linux-tároló üzembe helyezését az alkalmazáson 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. Az Azure Functions támogatott alaprendszerképei nyelvspecifikusak. Tekintse meg az Azure Functions alaprendszerkép-adattárát.

A Functions csapata elkötelezett amellett, hogy havi frissítéseket tegyen közzé ezekhez az alaplemezké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 egy üzembe helyezést is meghatározhat a függvénykódhoz, amely a következő módszereket tartalmazhatja:

A Flex Consumption csomag a projektkódot zip-tömörített csomagfájlban tartja fenn egy üzembehelyezési tárolóként ismert Blob Storage-tá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-üzembe helyezés során ezt egy 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ó

Az üzembe helyezéshez használt konkrét tárfiók és tároló, a hitelesítési módszer és a hitelesítő adatok a functionAppConfig.deployment.storageproperties hely elemében vannak beállítva. A tárolónak és minden alkalmazásbeállításnak léteznie kell az alkalmazás létrehozásakor. 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:

functionAppConfig: {
  deployment: {
    storage: {
      type: 'blobContainer'
      value: '${storage.outputs.primaryBlobEndpoint}${deploymentStorageContainerName}'
      authentication: {
        type: 'SystemAssignedIdentity'
      }
    }
  }
  scaleAndConcurrency: {
    maximumInstanceCount: maximumInstanceCount
    instanceMemoryMB: instanceMemoryMB
  }
  runtime: { 
    name: functionAppRuntime
    version: functionAppRuntimeVersion
  }
}

Ez a példa az AVM függvényalkalmazásokat használ. A kódrészlet kontextusában lásd ezt az üzembe helyezési példát.

Felügyelt identitások használatakor engedélyeznie kell azt is, hogy a függvényalkalmazás 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 az erőforrás-hatókörű szerepkör-hozzárendeléshez használja az AVM-et. A kódrészlet kontextusában lásd ezt az üzembe helyezési példát.

Ebben a példában ismernie kell a hozzárendelt szerepkör GUID-értékét. Ezt az azonosítóértéket bármilyen felhasználóbarát szerepkörnévhez lekérheti az az role definition list paranccsal, ahogyan ebben a példában is látható:

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

Ha felügyelt identitások helyett kapcsolati sztring használ, ehelyett be kell állítania az authentication.typeStorageAccountConnectionStringauthentication.storageAccountConnectionStringName üzembehelyezési tárfiókot tartalmazó alkalmazásbeállítás nevét kapcsolati sztring.

Ü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 amelyet más Functions-üzemeltetési csomagok zip-üzembe helyezéséhez használna. A csomagfájl nevének azonban magának a fájlnak 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 az alkalmazás sikeresen üzembe helyezhető legyen az Azure Resource Manager használatával, fontos tisztában lenni az erőforrások Azure-ban való üzembe helyezésének módjával. A legtöbb példában a legfelső szintű konfigurációkat a rendszer a használatával siteConfigalkalmazza. Fontos, hogy ezeket a konfigurációkat a legfelső szinten állítsa be, mivel ezek információt közvetítenek a Functions-futtatókörnyezetbe és az üzembe helyezési motorba. A gyermekerőforrás sourcecontrols/web alkalmazása előtt felső szintű információkra van szükség. Bár ezeket a beállításokat a gyermekszintű config/appSettings erőforrásban is 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-telepítés ajánlott módja a függvényalkalmazás kódjának üzembe helyezésének. 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 csomag követelményeit, tekintse meg az Azure Functions Zip-alapú üzembe helyezését. Erőforrás-üzembe helyezés automatizálása esetén hivatkozhat az .zip üzembehelyezé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 .

Egy Linux-alapú használatalapú csomag esetében állítsa be az üzembehelyezési csomag URI-ját közvetlenül a beállításban, ahogyan az ebben a WEBSITE_RUN_FROM_PACKAGE példasablonban 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@2021-02-01' = {
  name: '${functionAppName}/ZipDeploy'
  location: location
  properties: {
    packageUri: packageUri
  }
}

A zip-alapú üzembehelyezési erőforrások sablonba való felvételekor tartsa szem előtt az alábbi szempontokat:

  • A Linuxon futó fogyasztási csomagok nem támogatják WEBSITE_RUN_FROM_PACKAGE = 1a . Ehelyett közvetlenül a beállításban kell beállítania az üzembehelyezési csomag URI-ját WEBSITE_RUN_FROM_PACKAGE . További információért lásd: WEBSITE_RUN_FROM_PACKAGE. Egy példasablont a Linuxon üzemeltetett függvényalkalmazás egy használatalapú csomagban talál.

  • A packageUri függvények által elérhető helynek kell lennie. Fontolja meg az Azure Blob Storage használatát közös hozzáférésű jogosultságkóddal (SAS). Az SAS lejárta után a Functions már nem tudja elérni a megosztást az üzembe helyezé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 állítsa be az összes szükséges alkalmazásbeállítást a appSettings gyűjteményben. 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 üzembe helyezést kell használnia az üzembehelyezési folyamatokban és az automatizálásban. További információ: Zip deployment for Azure Functions.

Távoli buildek

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 azt jelenti, hogy alapértelmezés szerint nem futnak testreszabások.

Vannak olyan forgatókönyvek, amelyek megkövetelik, hogy távolról újraépítse 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 egy alkalmazást üzembe helyeznek a Windowsban, a rendszer nyelvspecifikus parancsokat futtat (például dotnet restore C#-alkalmazásokhoz vagy npm install Node.js-alkalmazásokhoz).

A folyamatos integrációhoz szükséges buildelési folyamatok engedélyezéséhez adja hozzá SCM_DO_BUILD_DURING_DEPLOYMENT=true az alkalmazásbeállításokat az üzembehelyezési kódhoz, és távolítsa el a WEBSITE_RUN_FROM_PACKAGE teljes elemet.

Linux-tárolók

Ha tárolóalapú függvényalkalmazást helyez üzembe egy Azure Functions Premium- vagy Dedikált Azure Functions-csomagban, a következőt 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@2022-03-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: '~14'
        }
        {
          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
  ]
}

Tárolóalapú függvények Azure Container Appsben való üzembe helyezésekor a sablonnak a következőnek kell lennie:

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

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@2022-03-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
  ]
}

Ha függvényeket helyez üzembe az Azure Arcban, a függvényalkalmazás-erőforrás mezőjéhez kind beállított érték az üzembe helyezés típusától függ:

Üzembe helyezés típusa kind mezőérték
Csak kódalapú üzembe helyezés functionapp,linux,kubernetes
Tárolók üzembe helyezése functionapp,linux,kubernetes,container

Azt is be kell állítania, ahogyan az customLocationIdüzemeltetési terv erőforrásához tette.

A .NET 6 gyorsútmutató-rendszerképet használó tárolóalapú függvényalkalmazás definíciója a következő példához hasonlóan nézhet ki:

resource functionApp 'Microsoft.Web/sites@2022-03-01' = {
  name: functionAppName
  kind: 'kubernetes,functionapp,linux,container'
  location: location
  extendedLocation: {
    name: customLocationId
  }
  properties: {
    serverFarmId: hostingPlanName
    siteConfig: {
      linuxFxVersion: 'DOCKER|mcr.microsoft.com/azure-functions/4-dotnet-isolated6.0-appservice-quickstart'
      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
        }
      ]
      alwaysOn: true
    }
  }
  dependsOn: [
    storageAccount
    hostingPlan
  ]
}

Alkalmazáskonfiguráció

A Flex Consumption-csomagban a függvényalkalmazást kétféle tulajdonsággal konfigurálhatja az Azure-ban:

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

Ezek az alkalmazáskonfigurációk a következőkben vannak fenntartva functionAppConfig:

Behavior Beállítás a következőben: 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 Functions a következő lehetőségeket kínálja a függvényalkalmazás azure-beli konfigurálásához:

Configuration Microsoft.Web/sites ingatlan
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:

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

  • 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 azok a skálázási csoportok, amelyek mindig készen állnak a méretezési döntések meghozatalára. Ez a példa mind a csoport, mind a http nem csoportosított eseményindító típusú egyetlen függvény helloworldmindig készen álló számát állítja be:
      alwaysReady: [
    {
      name: 'http'
      instanceCount: 2
    }
    {
      name: 'function:helloworld'
      instanceCount: 1
    }
  ]
  • Fontos szempontokat kell figyelembe vennie, amikor automatikus üzembe helyezést kell beállítania WEBSITE_CONTENTSHARE . Részletes útmutatásért tekintse meg a WEBSITE_CONTENTSHARE hivatkozást.

  • Az alkalmazásbeállításokat mindig a siteConfig/appSettings létrehozott erőforrás gyűjteményeként Microsoft.Web/sites kell meghatároznia, ahogyan az ebben a cikkben található példákban is látható. 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 belefoglalja a frissítésbe. 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 az Azure CLI, az Azure PowerShell vagy az Azure Portal használatával végezheti el ezeket a módosításokat. További információ: Az alkalmazásbeállítások használata.

  • Ha lehetséges, felügyelt identitásalapú kapcsolatokat kell használnia 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-alkalmazás Szolgáltatás 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 függvényei.

A ponterőforrás ugyanúgy van definiálva, mint egy függvényalkalmazás-erőforrás (Microsoft.Web/sites), de ehelyett az erőforrás-azonosítót Microsoft.Web/sites/slots használja. A Prémium csomagban éles és előkészítési pontot egyaránt létrehozó üzembe helyezést (Bicep- és ARM-sablonokban is) lásd : Azure Function App with a Deployment Slot.

A tárolóhelyek sablonok használatával történő felcserélésével kapcsolatos további információkért lásd : Automate with Resource Manager templates.

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

  • Ne állítsa be explicit módon a beállítást az WEBSITE_CONTENTSHARE üzembehelyezési pont definíciójában. Ez a beállítás akkor jön létre, ha az alkalmazás az üzembehelyezési ponton jön létre.

  • 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 egy vagy több erőforrást biztonságossá tettek a virtuális hálózatokkal való integrációval. A függvényalkalmazás virtuális hálózati integrációját egy Microsoft.Web/sites/networkConfig erőforrás 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ókért tekintse meg az Azure Functions hálózatkezelési lehetőségeit.

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:

  • A nagy léptékű HTTP-aktivált függvény egy virtuális hálózat által védett eseményközponthoz csatlakozik: A HTTP által aktivált függvény (.NET izolált feldolgozó mód) fogadja a hívásokat bármely forrásból, majd a http-hívások törzsét egy virtuális hálózaton futó biztonságos eseményközpontba küldi virtuális hálózati integrációval.
  • A függvényt egy virtuális hálózaton biztonságos Service Bus-üzenetsor aktiválja: A Python-függvényeket egy virtuális hálózaton biztonságos Service Bus-üzenetsor aktiválja. Az üzenetsor privát végpont használatával érhető el a virtuális hálózaton. A virtuális hálózat virtuális gépe üzenetek küldésére szolgál.

Biztonságos tárfiókot használó központi telepítés létrehozásakor 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 a Microsoft.Storage/storageAccounts/fileServices/shares példában (WEBSITE_CONTENTSHARE|) látható érték alapján hoz létre erőforrást. 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-sablonpéldákat 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
Függvényalkalmazás létrehozása virtuális hálózati integrációval A függvényalkalmazás egy virtuális hálózatban jön létre, amelyben 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, nem férhet hozzá a tárfiókhoz 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

A gazdagépszintű függvényelérési kulcsok Azure-erőforrásokként vannak definiálva. Ez azt jelenti, hogy az ARM-sablonokban és Bicep-fájlokban gazdakulcsokat hozhat létre és kezelhet. A gazdagépkulcs típus típusú Microsoft.Web/sites/host/functionKeyserőforrásként van definiálva. Ez a példa létrehoz egy gazdagépszintű hozzáférési kulcsot a függvényalkalmazás létrehozásakor:my_custom_key

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 tartalmazhat egy tulajdonságot value is, amely egy adott kulcs beállításához használható.

Ha nem állítja be a tulajdonságot, a value Functions automatikusan létrehoz egy új kulcsot az erőforrás létrehozásakor, ami ajánlott. A hozzáférési kulcsokkal 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 hozzáférési kulcsok használata az Azure Functionsben című témakört.

A sablon létrehozása

A Bicep- vagy ARM-sablonokkal rendelkező szakértők egy egyszerű szövegszerkesztővel manuálisan kódohatják az üzemelő példányokat. A többiek számára többféleképpen is egyszerűbbé teheti a fejlesztési folyamatot:

  • Visual Studio Code: Vannak olyan bővítmények, amelyek segítenek a Bicep-fájlok és az ARM-sablonok használatában. Ezekkel az eszközökkel meggyőződhet arról, hogy a kód helyes, és alapvető ellenőrzést biztosítanak.

  • Azure Portal: 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ő egy Sablon letöltése automatizálási hivatkozással rendelkezik.

    Töltse le a sablonhivatkozást az Azure Functions létrehozási folyamatából az Azure Portalon.

    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 következő módszerekkel ellenőrizheti a sablont az üzembe helyezés előtt:

A következő Azure-erőforráscsoport üzembe helyezési v2 feladata , amely deploymentMode: 'Validation' arra utasítja az Azure Pipelinest, hogy ellenőrizze a sablont.

- 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 az alábbi módszerek bármelyikét használhatja:

Üzembe helyezés az Azure-ban gomb

Note

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

Cserélje le <url-encoded-path-to-azuredeploy-json> a fájl GitHubon található nyers elérési útját annak URL-címmel kódolt verziójára.

Í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

Az alábbi 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 helyi futtatáshoz telepítve kell lennie az Azure PowerShellnek . Az Azure-ba való bejelentkezéshez először futtatnia kell a parancsot Connect-AzAccount.

# 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álhat egy ehhez hasonló sablont, amely egy használatalapú csomagban hoz létre függvényalkalmazást Windows rendszeren.

Következő lépések

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

  • Last updated on