Distribuire un'app di scalabilità automatica usando un modelloDeploy an autoscaling app using a template

I modelli di Azure Resource Manager sono un ottimo modo di distribuire gruppi di risorse correlate.Azure Resource Manager templates are a great way to deploy groups of related resources. Questa esercitazione spiega come distribuire un semplice set di scalabilità e descrive come distribuire una semplice applicazione di scalabilità automatica in un set di scalabilità usando un modello di Azure Resource Manager.This tutorial builds on Deploy a simple scale set and describes how to deploy a simple autoscaling application on a scale set using an Azure Resource Manager template. È anche possibile configurare la scalabilità automatica usando PowerShell, l'interfaccia della riga di comando o il portale.You can also set up autoscaling using PowerShell, CLI, or the portal. Per altre informazioni, vedere la panoramica del ridimensionamento automatico.For more information, see Autoscale overview.

Due modelli di avvio rapidoTwo quickstart templates

Quando si distribuisce un set di scalabilità, è possibile installare nuovo software in un'immagine della piattaforma usando un'estensione della macchina virtuale.When you deploy a scale set you can install new software on a platform image using a VM Extension. Le estensioni della macchina virtuale sono piccole applicazioni che eseguono attività di configurazione e automazione post-distribuzione nelle macchine virtuali di Azure, come ad esempio la distribuzione di un'app.A VM extension is a small application that provides post-deployment configuration and automation tasks on Azure virtual machines, such as deploying an app. Il repository Azure/azure-quickstart-templates di GitHub include due diversi modelli di esempio che illustrano come distribuire un'applicazione di scalabilità automatica in un set di scalabilità usando le estensioni della macchina virtuale.Two different sample templates are provided in Azure/azure-quickstart-templates which show how to deploy an autoscaling application onto a scale set using VM extensions.

Server HTTP Python in LinuxPython HTTP server on Linux

Il modello di esempio server HTTP Python in Linux consente di distribuire una semplice applicazione di scalabilità automatica in esecuzione in un set di scalabilità di Linux.The Python HTTP server on Linux sample template deploys a simple autoscaling application running on a Linux scale set. Bottle, un framework Web Python, e un semplice server HTTP vengono distribuiti in ogni macchina virtuale del set di scalabilità usando un'estensione script personalizzata della macchina virtuale.Bottle, a Python web framework, and a simple HTTP server are deployed on each VM in the scale set using a custom script VM extension. Le prestazioni del set di scalabilità aumentano quando l'utilizzo medio della CPU tra tutte le macchine virtuali è superiore al 60% e vengono ridotte quando l'utilizzo medio della CPU è inferiore al 30%.The scale set scales up when average CPU utilization across all VMs is greater than 60% and scales down when the average CPU utilization is less than 30%.

Oltre alla risorsa del set di scalabilità, il modello di esempio azuredeploy.json dichiara anche le risorse di impostazioni di rete virtuale, indirizzo IP pubblico, bilanciamento del carico e scalabilità automatica.In addition to the scale set resource, the azuredeploy.json sample template also declares virtual network, public IP address, load balancer, and autoscale settings resources. Per altre informazioni sulla creazione di queste risorse in un modello, vedere Set di scalabilità Linux con scalabilità automatica.For more information on creating these resources in a template, see Linux scale set with autoscale.

Nel modello azuredeploy.json la proprietà extensionProfile della risorsa Microsoft.Compute/virtualMachineScaleSets specifica un'estensione script personalizzata.In the azuredeploy.json template, the extensionProfile property of the Microsoft.Compute/virtualMachineScaleSets resource specifies a custom script extension. fileUris specifica la posizione degli script.fileUris specifies the script(s) location. In questo caso si tratta di due file: workserver.py, che definisce un semplice server HTTP, e installserver.sh, che installa Bottle e avvia il server HTTP.In this case, two files: workserver.py, which defines a simple HTTP server, and installserver.sh, which installs Bottle and starts the HTTP server. commandToExecute specifica il comando da eseguire dopo la distribuzione del set di scalabilità.commandToExecute specifies the command to run after the scale set has been deployed.

          "extensionProfile": {
            "extensions": [
              {
                "name": "lapextension",
                "properties": {
                  "publisher": "Microsoft.Azure.Extensions",
                  "type": "CustomScript",
                  "typeHandlerVersion": "2.0",
                  "autoUpgradeMinorVersion": true,
                  "settings": {
                    "fileUris": [
                      "https://raw.githubusercontent.com/Azure/azure-quickstart-templates/master/201-vmss-bottle-autoscale/installserver.sh",
                      "https://raw.githubusercontent.com/Azure/azure-quickstart-templates/master/201-vmss-bottle-autoscale/workserver.py"
                    ],
                    "commandToExecute": "bash installserver.sh"
                  }
                }
              }
            ]
          }

Applicazione ASP.NET MVC in WindowsASP.NET MVC application on Windows

Il modello di esempio applicazione ASP.NET MVC in Windows consente di distribuire una semplice app ASP.NET MVC in esecuzione in IIS nel set di scalabilità di Windows.The ASP.NET MVC application on Windows sample template deploys a simple ASP.NET MVC app running in IIS on Windows scale set. IIS e l'app MVC vengono distribuiti tramite l'estensione della macchina virtuale Configurazione dello stato desiderato (DSC) di PowerShell.IIS and the MVC app are deployed using the PowerShell desired state configuration (DSC) VM extension. Le prestazioni del set di scalabilità aumentano (in una sola istanza di macchina virtuale per volta) quando l'utilizzo della CPU è superiore al 50% per 5 minuti.The scale set scales up (on VM instance at a time) when CPU utilization is greater than 50% for 5 minutes.

Oltre alla risorsa del set di scalabilità, il modello di esempio azuredeploy.json dichiara anche le risorse di impostazioni di rete virtuale, indirizzo IP pubblico, bilanciamento del carico e scalabilità automatica.In addition to the scale set resource, the azuredeploy.json sample template also declares virtual network, public IP address, load balancer, and autoscale settings resources. Questo modello illustra anche l'aggiornamento dell'applicazione.This template also demonstrates application upgrade. Per altre informazioni sulla creazione di queste risorse in un modello, vedere Set di scalabilità Windows con scalabilità automatica.For more information on creating these resources in a template, see Windows scale set with autoscale.

Nel modello azuredeploy.json, la proprietà extensionProfile della risorsa Microsoft.Compute/virtualMachineScaleSets specifica un'estensione configurazione dello stato desiderato (DSC) che consente di installare IIS e un'app Web predefinita da un pacchetto WebDeploy.In the azuredeploy.json template, the extensionProfile property of the Microsoft.Compute/virtualMachineScaleSets resource specifies a desired state configuration (DSC) extension which installs IIS and a default web app from a WebDeploy package. Lo script IISInstall.ps1 consente di installare IIS nella macchina virtuale e si trova nella cartella DSC.The IISInstall.ps1 script installs IIS on the virtual machine and is found in the DSC folder. L'app Web MVC si trova nella cartella WebDeploy.The MVC web app is found in the WebDeploy folder. I percorsi per lo script di installazione e l'app Web sono definiti nei parametri powershelldscZip e webDeployPackage del file azuredeploy.parameters.json.The paths to the install script and the web app are defined in the powershelldscZip and webDeployPackage parameters in the azuredeploy.parameters.json file.

          "extensionProfile": {
            "extensions": [
              {
                "name": "Microsoft.Powershell.DSC",
                "properties": {
                  "publisher": "Microsoft.Powershell",
                  "type": "DSC",
                  "typeHandlerVersion": "2.9",
                  "autoUpgradeMinorVersion": true,
                  "forceUpdateTag": "[parameters('powershelldscUpdateTagVersion')]",
                  "settings": {
                    "configuration": {
                      "url": "[variables('powershelldscZipFullPath')]",
                      "script": "IISInstall.ps1",
                      "function": "InstallIIS"
                    },
                    "configurationArguments": {
                      "nodeName": "localhost",
                      "WebDeployPackagePath": "[variables('webDeployPackageFullPath')]"
                    }
                  }
                }
              }
            ]
          }

Distribuire il modelloDeploy the template

Il modo più semplice per distribuire il modello server HTTP Python in Linux o applicazione ASP.NET MVC in Windows consiste nell'usare il pulsante Distribuisci in Azure, presente nei file leggimi in GitHub.The simplest way to deploy the Python HTTP server on Linux or ASP.NET MVC application on Windows template is to use the Deploy to Azure button found in the in the readme files in GitHub. È inoltre possibile usare PowerShell o l'interfaccia della riga di comando di Azure per distribuire i modelli di esempio.You can also use PowerShell or Azure CLI to deploy the sample templates.

PowerShellPowerShell

Copiare i file del server HTTP Python in Linux o dell'applicazione ASP.NET MVC in Windows dal repository GitHub a una cartella nel computer locale.Copy the Python HTTP server on Linux or ASP.NET MVC application on Windows files from the GitHub repo to a folder on your local computer. Aprire il file azuredeploy.parameters.json e aggiornare i valori predefiniti dei parametri vmssName, adminUsername e adminPassword.Open the azuredeploy.parameters.json file and update the default values of the vmssName, adminUsername, and adminPassword parameters. Salvare lo script di PowerShell seguente come deploy.ps1 nella cartella di esempio come modello azuredeploy.json.Save the following PowerShell script to deploy.ps1 in the same folder as the azuredeploy.json template. Per distribuire il modello di esempio, eseguire lo script deploy.ps1 da una finestra di comando di PowerShell.To deploy the sample template run the deploy.ps1 script from a PowerShell command window.

param(
 [Parameter(Mandatory=$True)]
 [string]
 $subscriptionId,

 [Parameter(Mandatory=$True)]
 [string]
 $resourceGroupName,

 [string]
 $resourceGroupLocation,

 [Parameter(Mandatory=$True)]
 [string]
 $deploymentName,

 [string]
 $templateFilePath = "template.json",

 [string]
 $parametersFilePath = "parameters.json"
)

<#
.SYNOPSIS
    Registers RPs
#>
Function RegisterRP {
    Param(
        [string]$ResourceProviderNamespace
    )

    Write-Host "Registering resource provider '$ResourceProviderNamespace'";
    Register-AzureRmResourceProvider -ProviderNamespace $ResourceProviderNamespace;
}

#******************************************************************************
# Script body
# Execution begins here
#******************************************************************************
$ErrorActionPreference = "Stop"

# sign in
Write-Host "Logging in...";
Login-AzureRmAccount;

# select subscription
Write-Host "Selecting subscription '$subscriptionId'";
Select-AzureRmSubscription -SubscriptionID $subscriptionId;

# Register RPs
$resourceProviders = @("microsoft.compute","microsoft.insights","microsoft.network");
if($resourceProviders.length) {
    Write-Host "Registering resource providers"
    foreach($resourceProvider in $resourceProviders) {
        RegisterRP($resourceProvider);
    }
}

#Create or check for existing resource group
$resourceGroup = Get-AzureRmResourceGroup -Name $resourceGroupName -ErrorAction SilentlyContinue
if(!$resourceGroup)
{
    Write-Host "Resource group '$resourceGroupName' does not exist. To create a new resource group, please enter a location.";
    if(!$resourceGroupLocation) {
        $resourceGroupLocation = Read-Host "resourceGroupLocation";
    }
    Write-Host "Creating resource group '$resourceGroupName' in location '$resourceGroupLocation'";
    New-AzureRmResourceGroup -Name $resourceGroupName -Location $resourceGroupLocation
}
else{
    Write-Host "Using existing resource group '$resourceGroupName'";
}

# Start the deployment
Write-Host "Starting deployment...";
if(Test-Path $parametersFilePath) {
    New-AzureRmResourceGroupDeployment -ResourceGroupName $resourceGroupName -TemplateFile $templateFilePath -TemplateParameterFile $parametersFilePath;
} else {
    New-AzureRmResourceGroupDeployment -ResourceGroupName $resourceGroupName -TemplateFile $templateFilePath;
}

Interfaccia della riga di comando di AzureAzure CLI

#!/bin/bash
set -euo pipefail
IFS=$'\n\t'

# -e: immediately exit if any command has a non-zero exit status
# -o: prevents errors in a pipeline from being masked
# IFS new value is less likely to cause confusing bugs when looping arrays or arguments (e.g. $@)

usage() { echo "Usage: $0 -i <subscriptionId> -g <resourceGroupName> -n <deploymentName> -l <resourceGroupLocation>" 1>&2; exit 1; }

declare subscriptionId=""
declare resourceGroupName=""
declare deploymentName=""
declare resourceGroupLocation=""

# Initialize parameters specified from command line
while getopts ":i:g:n:l:" arg; do
    case "${arg}" in
        i)
            subscriptionId=${OPTARG}
            ;;
        g)
            resourceGroupName=${OPTARG}
            ;;
        n)
            deploymentName=${OPTARG}
            ;;
        l)
            resourceGroupLocation=${OPTARG}
            ;;
        esac
done
shift $((OPTIND-1))

#Prompt for parameters is some required parameters are missing
if [[ -z "$subscriptionId" ]]; then
    echo "Subscription Id:"
    read subscriptionId
    [[ "${subscriptionId:?}" ]]
fi

if [[ -z "$resourceGroupName" ]]; then
    echo "ResourceGroupName:"
    read resourceGroupName
    [[ "${resourceGroupName:?}" ]]
fi

if [[ -z "$deploymentName" ]]; then
    echo "DeploymentName:"
    read deploymentName
fi

if [[ -z "$resourceGroupLocation" ]]; then
    echo "Enter a location below to create a new resource group else skip this"
    echo "ResourceGroupLocation:"
    read resourceGroupLocation
fi

#templateFile Path - template file to be used
templateFilePath="template.json"

if [ ! -f "$templateFilePath" ]; then
    echo "$templateFilePath not found"
    exit 1
fi

#parameter file path
parametersFilePath="parameters.json"

if [ ! -f "$parametersFilePath" ]; then
    echo "$parametersFilePath not found"
    exit 1
fi

if [ -z "$subscriptionId" ] || [ -z "$resourceGroupName" ] || [ -z "$deploymentName" ]; then
    echo "Either one of subscriptionId, resourceGroupName, deploymentName is empty"
    usage
fi

#login to azure using your credentials
az account show 1> /dev/null

if [ $? != 0 ];
then
    az login
fi

#set the default subscription id
az account set --name $subscriptionId

set +e

#Check for existing RG
az group show $resourceGroupName 1> /dev/null

if [ $? != 0 ]; then
    echo "Resource group with name" $resourceGroupName "could not be found. Creating new resource group.."
    set -e
    (
        set -x
        az group create --name $resourceGroupName --location $resourceGroupLocation 1> /dev/null
    )
    else
    echo "Using existing resource group..."
fi

#Start deployment
echo "Starting deployment..."
(
    set -x
    az group deployment create --name $deploymentName --resource-group $resourceGroupName --template-file $templateFilePath --parameters $parametersFilePath
)

if [ $?  == 0 ];
 then
    echo "Template has been successfully deployed"
fi

Passaggi successiviNext steps

È possibile distribuire il modello precedente seguendo quanto indicato nella documentazione di Azure Resource Manager.You can deploy the preceding template by following the Azure Resource Manager documentation.

Questa serie di esercitazioni può essere avviata dall'articolo sul modello di set di scalabilità a validità minima.You can start this tutorial series from the minimum viable scale set template article.

È possibile vedere come modificare il modello di set di scalabilità a validità minima per distribuire il set di scalabilità in una rete virtuale esistente.You can see how to modify the minimum viable scale set template to deploy the scale set into an existing virtual network.

È possibile vedere come modificare il modello di set di scalabilità a validità minima per distribuire il set di scalabilità con un'immagine personalizzata.You can see how to modify the minimum viable scale set template to deploy the scale set with a custom image.

È possibile vedere come modificare il modello di set di scalabilità a validità minima per distribuire un set di scalabilità Linux con scalabilità automatica basata su guest.You can see how to modify the minimum viable scale set template to deploy a Linux scale set with guest-based autoscale.

Per informazioni più generali al riguardo, vedere la panoramica sui set di scalabilità.For more general information about scale sets, refer to the scale set overview page.