Schaalinstellingen per app implementeren voor high-density-hosting

Opmerking

We raden u aan om de Azure Az PowerShell-module te gebruiken om met Azure te communiceren. Zie Azure PowerShell installeren om aan de slag te gaan. Om te leren hoe u naar de Az PowerShell-module kunt migreren, zie Migrate Azure PowerShell from AzureRM to Az.

U kunt uw Azure App Service-apps schalen door het App Service-plan te schalen waarop ze worden uitgevoerd. Standaard is de eigenschap false op planniveau perSiteScaling, en maakt elke app en elk implementatieslot gebruik van alle beschikbare instanties in het plan.

Wanneer perSiteScaling is true, kan elke app en deploymentslot zijn eigen siteConfig.numberOfWorkers limiet hebben. Een plan kan bijvoorbeeld een geconfigureerde capaciteit van 10 werknemers hebben, terwijl een app een geconfigureerde limiet van vijf werknemers heeft. Elk implementatieslot heeft zijn eigen limiet; het configureren van de productietoepassing configureert niet automatisch ook de bijbehorende slots.

Opmerking

Schaalaanpassing per app is alleen beschikbaar voor de prijscategorieën Standard, Premium, Premium V2, Premium V3 en Isolated .
Een limiet per app vermindert de toegewijde capaciteit die is ingesteld voor het App Service-plan of de facturering daarvan op zichzelf niet.

Houd deze waarden duidelijk:

Geconfigureerde plancapaciteit: De sku.capacity waarde van het plan.
Geconfigureerde app- of slotworkerlimiet: De siteConfig.numberOfWorkers waarde van de resource.
Waargenomen actieve app-instanties: Een point-in-time runtime-observatie. Het daadwerkelijke aantal kan niet hoger zijn dan het beschikbare aantal planmedewerkers. Plan scale-in kan dit aantal onder de geconfigureerde app- of slotlimiet brengen.

Het platform plaatst een app op verschillende beschikbare planmedewerkers door een best-effort aanpak te gebruiken. De plaatsing is onafhankelijk van de metriek.

Scenario	Waardesemantiek
Limiet van `1`	De app of slot kan maximaal één beschikbare planmedewerker gebruiken. Kies deze waarde alleen wanneer een enkele werknemer plaatsing acceptabel is voor de werkdruk.
Limiet groter dan `1`	De prijs beperkt hoeveel verschillende planmedewerkers de app of slot kan gebruiken. Echte actieve instanties kunnen minder zijn.
Limiet boven de beschikbare plancapaciteit	Het aantal beschikbare planworkers begrenst het werkelijke aantal app- of slotinstanties.
Inschalen plannen	De app of slot kan draaien op minder werknemers dan de geconfigureerde limiet nadat de planwerknemers zijn verwijderd.

Schaalverdeling per app is een vaste, metriek-onafhankelijke plaatsing binnen de beschikbare werknemers van het plan. Het reageert niet op de vraag en wijzigt de plancapaciteit niet. Om de capaciteit aan te passen op basis van vraag, gebruik automatische schaalverdeling of Azure Monitor autoscale.

Belangrijk

Zoneredundantie verdeelt de instanties van App Service-plannen; er worden geen verborgen replica’s van apps gemaakt. Bij per-app-schaalvergroting staat een app- of slotlimiet van 1 plaatsing op maximaal één planinstantie toe en mag deze niet worden beschouwd als een gelijktijdige replica over meerdere zones. Limieten van 2 of meer maken plaatsing mogelijk voor meerdere verschillende planmedewerkers, maar bieden geen publieke garantie dat die app-instanties fysieke zones beslaan. Voor richtlijnen voor betrouwbaarheidsontwerp, zie Betrouwbaarheid in App Service.

Eigenschapsmodel en vereisten

Gebruik een ondersteund prijsniveau, een account waarmee je het plan, de app en de slot kunt bijwerken, en de huidige versie van je gekozen tool. De voorbeelden gebruiken Azure CLI 2.89.1 en Az PowerShell 16.2.0.

Scope	Eigenschap van resource	Voorbeeld
Abonnementsfunctie	`properties.perSiteScaling`	`true`
Capaciteit plannen	`sku.capacity`	`10`
App gewenste limiet	`properties.siteConfig.numberOfWorkers`	`5`
Gewenste slotlimiet	`properties.siteConfig.numberOfWorkers`	`2`
GET-antwoord voor app- of slotconfiguratie	`properties.numberOfWorkers`	`5` of `2`

In Azure CLI hebben vergelijkbare opties verschillende scopes: az appservice plan ... --number-of-workers bepaalt de plancapaciteit, terwijl az webapp config set ... --number-of-workers ze de app- of slotlimiet vaststellen.

Schaalinstelling per app

Gebruik het tabblad voor je favoriete tool. Vervang plaatsvervangende namen en locaties voordat je een commando uitvoert of een sjabloon uitrolt.

Kies voor het plan de stap voor maken of de stap voor bijwerken. De updatestap verandert alleen perSiteScaling; het verandert de bestaande capaciteit van het plan niet.

resourceGroup='<resource-group-name>'
planName='<app-service-plan-name>'
appName='<app-name>'
slotName='staging'
location='westus3'

# Create a plan with capacity 10 and per-app scaling.
az appservice plan create \
    --resource-group $resourceGroup \
    --name $planName \
    --location $location \
    --sku P1V3 \
    --number-of-workers 10 \
    --per-site-scaling

# Or enable per-app scaling on an existing plan without changing its capacity.
az appservice plan update \
    --resource-group $resourceGroup \
    --name $planName \
    --set properties.perSiteScaling=true

# Configure the production app and its staging slot independently.
az webapp config set \
    --resource-group $resourceGroup \
    --name $appName \
    --number-of-workers 5

az webapp config set \
    --resource-group $resourceGroup \
    --name $appName \
    --slot $slotName \
    --number-of-workers 2

Hier is het plan --number-of-workers 10 capaciteit. De configuratieoptie voor webapps met dezelfde naam is de gewenste app- of slotlimiet. Bekijk de geconfigureerde waarden:

az appservice plan show \
    --resource-group $resourceGroup \
    --name $planName \
    --query "{planCapacity:sku.capacity, perSiteScaling:perSiteScaling}"

az webapp config show \
    --resource-group $resourceGroup \
    --name $appName \
    --query "{appWorkerLimit:numberOfWorkers}"

az webapp config show \
    --resource-group $resourceGroup \
    --name $appName \
    --slot $slotName \
    --query "{slotWorkerLimit:numberOfWorkers}"

Voor commandodetails, zie az appservice plan en az webapp config.

Kies ofwel New-AzAppServicePlan of.Set-AzAppServicePlan Wanneer je Set-AzAppServicePlan planinstellingen wijzigt, herhaal -PerSiteScaling $true dan expliciet zodat de beoogde feature-status duidelijk blijft.

$ResourceGroup = '<resource-group-name>'
$AppServicePlan = '<app-service-plan-name>'
$WebApp = '<app-name>'
$Slot = 'staging'
$Location = 'westus3'

# Create a plan with capacity 10 and per-app scaling.
New-AzAppServicePlan -ResourceGroupName $ResourceGroup `
    -Name $AppServicePlan `
    -Location $Location `
    -Tier PremiumV3 `
    -WorkerSize Small `
    -NumberofWorkers 10 `
    -PerSiteScaling $true

# Or set the intended capacity and feature state on an existing plan.
Set-AzAppServicePlan -ResourceGroupName $ResourceGroup `
    -Name $AppServicePlan `
    -NumberofWorkers 10 `
    -PerSiteScaling $true

Set-AzWebApp -ResourceGroupName $ResourceGroup `
    -Name $WebApp `
    -NumberOfWorkers 5

Set-AzWebAppSlot -ResourceGroupName $ResourceGroup `
    -Name $WebApp `
    -Slot $Slot `
    -NumberOfWorkers 2

Gebruik de bijbehorende Get cmdlets om de waarden van het plan, de app en de slots te inspecteren:

$Plan = Get-AzAppServicePlan -ResourceGroupName $ResourceGroup -Name $AppServicePlan
[pscustomobject]@{
    PlanCapacity = $Plan.Sku.Capacity
    PerSiteScaling = $Plan.PerSiteScaling
}

(Get-AzWebApp -ResourceGroupName $ResourceGroup -Name $WebApp).SiteConfig.NumberOfWorkers
(Get-AzWebAppSlot -ResourceGroupName $ResourceGroup -Name $WebApp -Slot $Slot).SiteConfig.NumberOfWorkers

Voor details over de cmdlet, zie New-AzAppServicePlan, Set-AzAppServicePlan en Set-AzWebApp.

Dit Bicep-bestand maakt een plan, een app en een stagingslot met de voorbeeldwaarden.

param location string = resourceGroup().location
param appServicePlanName string
param appName string

resource appServicePlan 'Microsoft.Web/serverfarms@2024-11-01' = {
  name: appServicePlanName
  location: location
  sku: {
    name: 'P1v3'
    tier: 'PremiumV3'
    capacity: 10
  }
  properties: {
    perSiteScaling: true
  }
}

resource app 'Microsoft.Web/sites@2024-11-01' = {
  name: appName
  location: location
  properties: {
    serverFarmId: appServicePlan.id
    siteConfig: {
      numberOfWorkers: 5
    }
  }
}

resource stagingSlot 'Microsoft.Web/sites/slots@2024-11-01' = {
  parent: app
  name: 'staging'
  location: location
  properties: {
    serverFarmId: appServicePlan.id
    siteConfig: {
      numberOfWorkers: 2
    }
  }
}

Sla het bestand op als main.bicep, compileer het met az bicep build --file main.bicep, en deploy het met az deployment group create --resource-group <resource-group-name> --template-file main.bicep. Een succesvolle compilatie valideert syntaxis en resourcetypes; inspecteer de geconfigureerde waarden na de implementatie. Voor resourcedefinities, zie App Service-plannen, apps en deploymentslots.

Deze ARM-template definieert hetzelfde plan, dezelfde app en dezelfde stagingslot. De app hangt af van het abonnement, en de plek hangt af van de ouder-app.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "location": {
      "type": "string",
      "defaultValue": "[resourceGroup().location]"
    },
    "appServicePlanName": {
      "type": "string"
    },
    "appName": {
      "type": "string"
    }
  },
  "resources": [
    {
      "type": "Microsoft.Web/serverfarms",
      "apiVersion": "2024-11-01",
      "name": "[parameters('appServicePlanName')]",
      "location": "[parameters('location')]",
      "sku": {
        "name": "P1v3",
        "tier": "PremiumV3",
        "capacity": 10
      },
      "properties": {
        "perSiteScaling": true
      }
    },
    {
      "type": "Microsoft.Web/sites",
      "apiVersion": "2024-11-01",
      "name": "[parameters('appName')]",
      "location": "[parameters('location')]",
      "dependsOn": [
        "[resourceId('Microsoft.Web/serverfarms', parameters('appServicePlanName'))]"
      ],
      "properties": {
        "serverFarmId": "[resourceId('Microsoft.Web/serverfarms', parameters('appServicePlanName'))]",
        "siteConfig": {
          "numberOfWorkers": 5
        }
      }
    },
    {
      "type": "Microsoft.Web/sites/slots",
      "apiVersion": "2024-11-01",
      "name": "[format('{0}/{1}', parameters('appName'), 'staging')]",
      "location": "[parameters('location')]",
      "dependsOn": [
        "[resourceId('Microsoft.Web/sites', parameters('appName'))]"
      ],
      "properties": {
        "serverFarmId": "[resourceId('Microsoft.Web/serverfarms', parameters('appServicePlanName'))]",
        "siteConfig": {
          "numberOfWorkers": 2
        }
      }
    }
  ]
}

Sla het sjabloon op als azuredeploy.json, valideer het met az deployment group validate --resource-group <resource-group-name> --template-file azuredeploy.json, en deploy het vervolgens met az deployment group create --resource-group <resource-group-name> --template-file azuredeploy.json. Validatie en uitrol vereisen een Azure-context; JSON-parsing alleen valideert de resources niet tegen je abonnement. Voor schemadetails, zie App Service-plannen, apps en deploymentslots.

Gebruik het Azure Resource Manager-eindpunt voor je cloud als {managementEndpoint}. Voor publieke Azure is https://management.azure.comdeze waarde ; andere clouds gebruiken hun eigen endpoint.

Een plan PUT is een volledig aanmaak- of updateverzoek. Vermeld de locatie, SKU, capaciteit en eigendommen van het plan; stuur het volgende verzoek niet als een update alleen voor eigendommen.

PUT {managementEndpoint}/subscriptions/{subscriptionId}/resourceGroups/{resourceGroup}/providers/Microsoft.Web/serverfarms/{planName}?api-version=2024-11-01
Content-Type: application/json

{
  "location": "westus3",
  "sku": {
    "name": "P1v3",
    "tier": "PremiumV3",
    "capacity": 10
  },
  "properties": {
    "perSiteScaling": true
  }
}

Voor een bestaand plan gebruik je een partial PATCH om alleen de getoonde scalair-eigenschap te wijzigen:

PATCH {managementEndpoint}/subscriptions/{subscriptionId}/resourceGroups/{resourceGroup}/providers/Microsoft.Web/serverfarms/{planName}?api-version=2024-11-01
Content-Type: application/json

{
  "properties": {
    "perSiteScaling": true
  }
}

Voor de productie-app, update en lees de config/web bron:

PATCH {managementEndpoint}/subscriptions/{subscriptionId}/resourceGroups/{resourceGroup}/providers/Microsoft.Web/sites/{appName}/config/web?api-version=2024-11-01
Content-Type: application/json

{
  "properties": {
    "numberOfWorkers": 5
  }
}

GET {managementEndpoint}/subscriptions/{subscriptionId}/resourceGroups/{resourceGroup}/providers/Microsoft.Web/sites/{appName}/config/web?api-version=2024-11-01

Voor de staging-slot, voeg in het resource path het volgende op:/slots/{slotName}

PATCH {managementEndpoint}/subscriptions/{subscriptionId}/resourceGroups/{resourceGroup}/providers/Microsoft.Web/sites/{appName}/slots/{slotName}/config/web?api-version=2024-11-01
Content-Type: application/json

{
  "properties": {
    "numberOfWorkers": 2
  }
}

GET {managementEndpoint}/subscriptions/{subscriptionId}/resourceGroups/{resourceGroup}/providers/Microsoft.Web/sites/{appName}/slots/{slotName}/config/web?api-version=2024-11-01

Lees het plan met GET {managementEndpoint}/subscriptions/{subscriptionId}/resourceGroups/{resourceGroup}/providers/Microsoft.Web/serverfarms/{planName}?api-version=2024-11-01. Gedeeltelijke scalairverzoeken PATCH zijn veilig voor de getoonde velden omdat weggelaten instellingen behouden blijven. Voor operationele details, zie de App Service REST API-referentie.

De configuratie controleren

Controleer elke geconfigureerde waarde na een wijziging of implementatie.

Value	Verwacht voorbeeld	Waar te verifiëren
Abonnementsfunctie	`true`	Antwoord plannen `properties.perSiteScaling`
Capaciteit plannen	`10`	Reactie op plan `sku.capacity`
Gewenste limiet voor productie-app	`5`	Reactie van productie `config/webproperties.numberOfWorkers`
Gewenste limiet voor stagingslot	`2`	Slot `config/web` reactie `properties.numberOfWorkers`

Deze waarden zijn configuratiewaarden, geen waargenomen aantallen actieve instanties. Plaatsing tijdens runtime blijft zo goed mogelijk en is beperkt door beschikbare planworkers. Voordat je per-app schaalbaarheid combineert met zone-redundantie, bekijk de plancapaciteit en elke app- of slotlimiet in Set zone-redundantie voor een bestaand App Service-plan.

Configureer high-density hosting voor jouw scenario

Per-app schaalbaarheid is beschikbaar in zowel wereldwijde Azure-regio's als App Service Environments. Kies app- en slotlimieten op basis van de capaciteit en betrouwbaarheid van de werklast, in plaats van één limiet op elke workload toe te passen.

Voor een scenario met hoge dichtheid van hosting:

Wijs een App Service-plan aan als het plan voor hoge dichtheid en schaal het op naar de gewenste capaciteit.
Stel de PerSiteScaling vlag in op true in het App Service-plan.
Stel de numberOfWorkers limiet van elke app en de deployment slot in op basis van de behoeften.
- Een limiet van 1 biedt de hoogste dichtheid, maar gebruik het alleen voor workloads waarbij plaatsing op maximaal één planmedewerker acceptabel is.
- Gebruik een limiet van 2 of meer wanneer de werklast in aanmerking zou moeten komen voor plaatsing bij meerdere verschillende planmedewerkers, afhankelijk van de beschikbare plancapaciteit.
Bekijk de limieten onafhankelijk naarmate de werklastvereisten veranderen. Een app met meer gebruik kan bijvoorbeeld een limiet van 3 gebruiken voor meer verwerkingscapaciteit, terwijl een andere app kan gebruiken 1 wanneer een enkele werknemer plaatsing passend is.

Feedback

Is deze pagina nuttig?

Last updated on 2026-08-31