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

  • Cikk

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. Az Automation segítséget nyújt az alábbi forgatókönyvekhez:

  • Az erőforrás-telepítések integrálása a forráskóddal az Azure Pipelinesban és a GitHub Actions-alapú üzemelő példányokban.
  • Függvényalkalmazás és kapcsolódó erőforrások visszaállítása biztonsági másolatból.
  • Alkalmazástopológia többszöri üzembe helyezése.

Ez a cikk bemutatja, hogyan automatizálhatja az erőforrások létrehozását és az Azure Functions üzembe helyezését. A függvények által használt triggertől és kötéstől függően előfordulhat, hogy más erőforrásokat is üzembe kell helyeznie, amelyek nem tartoznak a jelen cikk hatókörébe.

A 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 Üzemelő példány típusa További információ:
Azure Functions-használati csomag Csak kóddal Használati terv
Azure Functions Flex-használati csomag Csak kóddal Rugalmas kihasználtságú csomag
Azure Functions Elastic Premium-csomag Kód | Konténer Prémium csomag
Dedikált Azure Functions-csomag (App Service) Kód | Konténer Dedikált terv
Azure Container Apps Csak tároló Az Azure Functionst üzemeltető Container Apps
Azure Arc Kód | Konténer App Service, Functions és Logic Apps az Azure Arcon (előzetes verzió)

Fontos

A Rugalmas használat csomag jelenleg előzetes verzióban érhető el.

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

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

  • A Bicep-telepítés több Bicep-fájlba is modulárisan telepíthető.

  • 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 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:

Erőforrás Követelmény Szintaxis és tulajdonságok referenciája
Tárfiók Kötelező Microsoft.Storage/storageAccounts
Application Insights-összetevő Ajánlott Microsoft.Insights/components*
Üzemeltetési terv Kötelező Microsoft.Web/serverfarms
Függvényalkalmazás Kötelező Microsoft.Web/sites

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

Erőforrás Követelmény Szintaxis és tulajdonságok referenciája
Tárfiók Kötelező Microsoft.Storage/storageAccounts
Application Insights-összetevő Ajánlott Microsoft.Insights/components*
Függvényalkalmazás Kötelező Microsoft.Web/sites

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

Erőforrás Követelmény Szintaxis és tulajdonságok referenciája
Tárfiók Kötelező Microsoft.Storage/storageAccounts
Application Insights-összetevő Ajánlott Microsoft.Insights/components*
Felügyelt környezet Kötelező Microsoft.App/managedEnvironments
Függvényalkalmazás Kötelező Microsoft.Web/sites

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

Erőforrás Követelmény Szintaxis és tulajdonságok referenciája
Tárfiók Kötelező Microsoft.Storage/storageAccounts
Application Insights-összetevő Ajánlott Microsoft.Insights/components1
App Service Kubernetes-környezet Kötelező Microsoft.ExtendedLocation/customLocations
Függvényalkalmazás Kötelező 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.

Előfeltételek

  • 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.

Fontos

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-account.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ó.

Üzembehelyezé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. Az üzemelő példányok konfigurálásáról további információt az üzembehelyezési források című témakörben talál.

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

resource blobServices 'blobServices' = if (!empty(containers)) {
  name: 'default'
  properties: {
    deleteRetentionPolicy: deleteRetentionPolicy
  }
  resource container 'containers' = [for container in containers: {
    name: container.name
    properties: {
      publicAccess: contains(container, 'publicAccess') ? container.publicAccess : 'None'
    }
  }]
}

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 Name FC1 következő értékéveltier: .sku>FlexConsumption

Ez a példaszakasz rugalmas használatú csomagot hoz létre:

resource flexFuncPlan 'Microsoft.Web/serverfarms@2023-12-01' = {
  name: planName
  location: location
  tags: tags
  kind: 'functionapp'
  sku: {
    tier: 'FlexConsumption'
    name: 'FC1'
  }
  properties: {
    reserved: true
  }
}

További információt a Flex Consumption plan mintaadattár teljes function.bicep fájljában talál.

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

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 sku vagy Name EP3 használatávalEP1EP2. 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.

Bicep-mintafájl/Azure Resource Manager-sablonért lásd: Függvényalkalmazás a Azure-alkalmazás Service-csomagban

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 sku a computeMode tulajdonságok értékével Dynamic 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 kind locationkívül helyezkedik propertiesel:

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 kubeEnvironmentProfile.id a Kubernetes-környezetazonosítót is be kell állítaniaextendedLocation, 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/sites kind 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ó.

resource flexFuncApp 'Microsoft.Web/sites@2023-12-01' = {
  name: appName
  location: location
  tags: tags
  kind: 'functionapp,linux'
  identity: {
    type: 'SystemAssigned'
  }
  properties: {
    serverFarmId: flexFuncPlan.id
    siteConfig: {
      appSettings: [
        {
          name: 'AzureWebJobsStorage__accountName'
          value: storage.name
        }
        {
          name: 'APPLICATIONINSIGHTS_CONNECTION_STRING'
          value: appInsights.properties.ConnectionString
        }
      ]
    }
    functionAppConfig: {
      deployment: {
        storage: {
          type: 'blobContainer'
          value: '${storage.properties.primaryEndpoints.blob}${deploymentStorageContainerName}'
          authentication: {
            type: 'SystemAssignedIdentity'
          }
        }
      }
      scaleAndConcurrency: {
        maximumInstanceCount: maximumInstanceCount
        instanceMemoryMB: instanceMemoryMB
      }
      runtime: { 
        name: functionAppRuntime
        version: functionAppRuntimeVersion
      }
    }
  }
}

További információt a Flex Consumption plan mintaadattár teljes function.bicep fájljában talál.

Feljegyzés

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 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:

Üzembehelyezési források

A Flex Consumption csomagban a projektkód egy Blob Storage-tárolóban közzétett zip-tömörített csomagból lesz üzembe helyezve. A további tudnivalókat lásd a Telepítés szolgáltatásban. 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.storage properties 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:

deployment: {
  storage: {
    type: 'blobContainer'
    value: '${storage.properties.primaryEndpoints.blob}${deploymentStorageContainerName}'
    authentication: {
      type: 'SystemAssignedIdentity'
    }
  }
}

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ó:

// Allow access from function app to storage account using a managed identity
resource storageRoleAssignment 'Microsoft.Authorization/roleAssignments@2020-04-01-preview' = {
  name: guid(storage.id, storageRoleDefinitionId)
  scope: storage
  properties: {
    roleDefinitionId: resourceId('Microsoft.Authorization/roleDefinitions', storageRoleDefinitionId)
    principalId: flexFuncApp.identity.principalId
    principalType: 'ServicePrincipal'
  }
}

A teljes referenciapéldát ebben a Bicep-fájlban talál.

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

Üzembehelyezési források

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ó: 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:

Üzemelő példány 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:

Konfiguráció 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:

Működés 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 memóriamé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

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:

Konfiguráció 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 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 Microsoft.Web/sites létrehozott erőforrás gyűjteményeként siteConfig/appSettings 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.

Ponttelepí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 üzemelő példányok

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 (ARM-sablon|Bicep-fájl) látható érték WEBSITE_CONTENTSHAREalapján hoz létre erőforrást. A webhelytulajdonságot vnetContentShareEnabled is igaz értékre kell állítania.

Feljegyzés

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 Leírás
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:

Beállítás Érték Leírás
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

Feljegyzés

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 nyers elérési útjának URL-címmel kódolt verziójára a azuredeploy.json GitHubon.

Í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 . Futtassa Connect-AzAccount a bejelentkezést.

# 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.