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. 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.
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
- 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.
- Ez a cikk feltételezi, hogy már létrehozott egy App Service-kompatibilis egyéni helyet egy Azure Arc-kompatibilis Kubernetes-fürtön. Az Egyéni Azure Arc-helyen üzemeltetett függvényalkalmazás létrehozásához az egyéni helyazonosítóra és a Kubernetes-környezetazonosítóra is szükség van.
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 web
van 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ávalEP1
EP2
. 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
location
kívül helyezkedik properties
el:
resource hostingPlan 'Microsoft.Web/serverfarms@2022-03-01' = {
...
{
extendedLocation: {
name: customLocationId
}
}
}
A terverőforrásnak a Kubernetes (K1
) értékét SKU
kell 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 siteConfig
alkalmazza. 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 = 1
a . Ehelyett közvetlenül a beállításban kell beállítania az üzembehelyezési csomag URI-játWEBSITE_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 aWEBSITE_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:
- Állítsa be a
linuxFxVersion
helybeállítást a tárolólemezkép azonosítójával. - A tároló magánregisztrációs adatbázisból való lekéréséhez állítsa be a szükséges
DOCKER_REGISTRY_SERVER_*
beállításokat. - Alkalmazásbeállítás beállítása
WEBSITES_ENABLE_APP_SERVICE_STORAGE
a következőrefalse
: .
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ékrefunctionapp,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ástMicrosoft.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 a konfigurációk a következőkben vannak fenntartva functionAppConfig
:
Működés | Beállítás a következőben: functionAppConfig |
---|---|
Nyelvi futtatókörnyezet | runtime.name |
Nyelvi verzió | runtime.version |
Példányok maximális száma | scaleAndConcurrency.maximumInstanceCount |
Példány memóriamérete | scaleAndConcurrency.instanceMemoryMB |
Üzembehelyezési forrás | deployment |
A Flex Consumption csomag az alábbi alkalmazásbeállításokat is támogatja:
- Kapcsolati sztringalapú beállítások:
- Felügyelt identitásalapú beállítások:
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:
- Fontos szempontokat kell figyelembe vennie, amikor automatikus üzembe helyezést kell beállítania
WEBSITE_CONTENTSHARE
. Részletes útmutatásért tekintse meg aWEBSITE_CONTENTSHARE
hivatkozást.
- Tárolótelepítések esetén is állítsa be
WEBSITES_ENABLE_APP_SERVICE_STORAGE
azfalse
értéket, mivel az alkalmazás tartalma magában a tárolóban van megadva.
Az alkalmazásbeállításokat mindig a
Microsoft.Web/sites
létrehozott erőforrás gyűjteményekéntsiteConfig/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_CONTENTSHARE
alapjá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/functionKeys
erő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.
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.