Creare un'app Web con iperscalabilità in Azure

Questa esercitazione illustra come scalare orizzontalmente un'app Web ASP.NET in Azure per ottimizzare le richieste degli utenti.

Prima di iniziare, verificare che nel computer sia installata l'interfaccia della riga di comando di Azure. È necessario anche disporre di Visual Studio sul computer locale per eseguire l'applicazione di esempio.

Passaggio 1: applicazione di esempio

In questo passaggio si imposta il progetto ASP.NET locale.

Clonare il repository di applicazione

Aprire il terminale della riga di comando desiderato ed eseguire CD in una directory di lavoro. Eseguire quindi i comandi seguenti per clonare l'applicazione di esempio.

git clone https://github.com/cephalin/HighScaleApp.git

Eseguire l'applicazione in Visual Studio

Aprire la soluzione in Visual Studio.

cd HighScaleApp
.\HighScaleApp.sln

Digitare F5 per eseguire l'applicazione.

Questa app Web ASP.NET di esempio deriva dal modello predefinito, mantiene le sessioni degli utenti e usa la cache di output. Vedere HighScaleApp\Controllers\HomeController.cs. Il metodo Index() aggiunge una parte di dati alla sessione.

Session.Add("visited", "true"); 

I metodi About() e Contact() memorizzano il relativo output nella cache.

[OutputCache(Duration = 60)]

Passaggio 2: distribuire in Azure

In questo passaggio si crea un'app Web di Azure, per poi distribuire in essa l'applicazione ASP.NET di esempio.

Creare un gruppo di risorse

Usare il comando az group create per creare un gruppo di risorse nell'area Europa occidentale. In un gruppo di risorse si inseriranno tutte le risorse che si vogliono gestire insieme, ad esempio l'app Web e il back-end del database SQL.

az group create --location "West Europe" --name myResourceGroup

Per visualizzare i possibili valori utilizzabili per ---location, usare il comando az appservice list-locations.

Creare un piano di servizio app

Usare il comando az appservice plan create per creare un piano di servizio app "B1".

az appservice plan create --name myAppServicePlan --resource-group myResourceGroup --sku B1

Un piano di servizio app è un'unità di scala, che può includere il numero desiderato di app da scalare verticalmente oppure orizzontalmente, oltre alla medesima infrastruttura del servizio app. A ogni piano viene inoltre assegnato un piano tariffario. I piani tariffari superiori includono un hardware migliore e più caratteristiche, ad esempio un numero maggiore di istanze di scalabilità orizzontale.

Per questa esercitazione, B1 è il livello minimo che consente la scalabilità orizzontale in tre istanze. È sempre possibile modificare il piano tariffario dell'app in un secondo momento eseguendo il comando az appservice plan update.

Creare un'app Web

Usare il comando az appservice web create per creare un'app Web con un nome univoco in $appName.

$appName = "<replace-with-a-unique-name>"
az appservice web create --name $appName --resource-group myResourceGroup --plan myAppServicePlan

Reimpostare le credenziali di distribuzione

Usare il comando az appservice web deployment user set per impostare le credenziali di distribuzione a livello di account per il servizio app.

az appservice web deployment user set --user-name <letters-numbers> --password <mininum-8-char-captital-lowercase-letters-numbers>

Configurare la distribuzione Git

Usare il comando az appservice web source-control config-local-git per configurare la distribuzione Git locale.

az appservice web source-control config-local-git --name $appName --resource-group myResourceGroup

Questo comando fornisce un output simile al seguente:

{
  "url": "https://user123@myuniqueappname.scm.azurewebsites.net/myuniqueappname.git"
}

Usare l'URL restituito per configurare Git remoto. Il comando seguente usa l'esempio di output precedente.

git remote add azure https://user123@myuniqueappname.scm.azurewebsites.net/myuniqueappname.git

Distribuire l'applicazione di esempio

È ora possibile distribuire l'applicazione di esempio. Eseguire git push.

git push azure master

Quando viene richiesta la password, usare quella specificata all'esecuzione di az appservice web deployment user set.

Passare all'app Web di Azure

Usare il comando az appservice web browse per osservare l'app in esecuzione in Azure.

az appservice web browse --name $appName --resource-group myResourceGroup

Passaggio 3: connettersi a Redis

In questo passaggio si configura una cache Redis di Azure come una cache esterna con percorso condiviso nell'app Web di Azure. È possibile usare rapidamente Redis per memorizzare nella cache l'output della pagina. In più, quando si scalano orizzontalmente le app Web in un secondo momento, Redis aiuta a mantenere le sessioni degli utenti su più istanze in maniera affidabile.

Creare una cache Redis di Azure

Usare il comando az redis create per creare una cache Redis di Azure e salvare l'output JSON. Usare un nome univoco in $cacheName.

$cacheName = "<replace-with-a-unique-cache-name>"
$redis = (az redis create --name $cacheName --resource-group myResourceGroup --location "West Europe" --sku-capacity 0 --sku-family C --sku-name Basic | ConvertFrom-Json)

Configurare l'applicazione per l'uso di Redis

Formattare la stringa di connessione per la cache.

$connstring = "$($redis.hostname):$($redis.sslPort),password=$($redis.accessKeys.primaryKey),ssl=True,abortConnect=False"
$connstring 

La seconda riga dovrebbe mostrare un output simile al seguente:

mycachename.redis.cache.windows.net:6380,password=/rQP/TLz1mrEPpmh9b/gnfns/t9vBRXqXn3i1RwBjGA=,ssl=True,abortConnect=False

In Visual Studio creare un file di configurazione Web nella radice del progetto denominato redis.config e incollarvi il codice seguente. In value usare la stringa di connessione dall'output di PowerShell.

<appSettings>
  <add key="RedisConnection" value="your-azure-redis-cache-connection-string"/>
</appSettings>

Se si osserva il file .gitignore nel repository Git, si noterà che è escluso dal controllo del codice sorgente. In questo modo le informazioni riservate vengono protette.

Aprire Web.config. Si noti l'elemento <appSettings file="redis.config">, che riceve l'impostazione creata in redis.config.

Individuare la sezione commentata che include <sessionState> e <caching>. Rimuovere il commento in questa sezione.

Questo codice cerca la stringa di connessione a Redis definita in RedisConnection.

Ora l'applicazione usa Redis per gestire sessioni e memorizzazione nella cache. Digitare F5 per eseguire l'applicazione. Se si desidera, è possibile scaricare un client di gestione di Redis per visualizzare i dati salvati nella cache.

Configurare la stringa di connessione in Azure

Per far funzionare l'applicazione in Azure è necessario configurare la medesima stringa di connessione a Redis nell'app Web di Azure. Poiché redis.config non viene mantenuto nel controllo del codice sorgente, non viene distribuito in Azure quando si esegue la distribuzione Git.

Usare il comando az appservice web config appsettings update per aggiungere la stringa di connessione con lo stesso nome (RedisConnection).

az appservice web config appsettings update --settings "RedisConnection=$connstring" --name $appName --resource-group myResourceGroup

Tenere presente che $connstring contiene la stringa di connessione formattata.

Ridistribuire l'applicazione in Azure

Usare i comandi di Git per inviare le modifiche in Azure

git add .
git commit -m "now use Redis providers"
git push azure master

Quando viene richiesta la password, usare quella specificata all'esecuzione di az appservice web deployment user set.

Passare all'app Web di Azure

Usare il comando az appservice web browse per visualizzare le modifiche pubblicate in Azure.

az appservice web browse --name $appName --resource-group myResourceGroup

Passaggio 4: scalare in più istanze

Il piano di servizio app è l'unità di scala per le app Web di Azure. Per scalare orizzontalmente l'app Web, è necessario scalare il piano di servizio app.

Usare il comando az appservice plan update per scalare orizzontalmente il piano di servizio app in tre istanze, ovvero il numero massimo consentito dal piano tariffario B1. Tenere presente che B1 è il piano tariffario scelto quando in precedenza si è creato il piano di servizio app.

az appservice plan update --name myAppServicePlan --resource-group myResourceGroup --number-of-workers 3 

Passaggio 5: scalare geograficamente

Durante la scalabilità geografica, si esegue l'app in più aree del cloud di Azure. Questa configurazione bilancia ulteriormente il carico dell'app in base all'area geografica e riduce i tempi di risposta posizionandola più vicina ai browser client.

In questo passaggio si scala l'app Web ASP.NET in una seconda area con Gestione traffico di Azure. Al termine del passaggio, si otterrà un'app Web in esecuzione in Europa occidentale (già creata) e un'app Web in esecuzione in Asia sud-orientale (non ancora creata). Entrambe le app verranno servite dallo stesso URL di Gestione traffico.

Scalare l'app Europa al livello Standard

Nel servizio app l'integrazione con Gestione traffico di Azure richiede il piano tariffario Standard. Usare il comando az appservice plan update per far passare a S1 il piano di servizio app.

az appservice plan update --name myAppServicePlan --resource-group myResourceGroup --sku S1

Creare un profilo di Gestione traffico

Usare il comando az network traffic-manager profile create per creare un profilo di Gestione traffico e aggiungerlo al gruppo di risorse. Usare un nome DNS univoco in $dnsName.

$dnsName = "<replace-with-unique-dns-name>"
az network traffic-manager profile create --name myTrafficManagerProfile --resource-group myResourceGroup --routing-method Performance --unique-dns-name $dnsName
Nota

--routing-method Performance specifica che questo profilo instrada il traffico utente all'endpoint più vicino.

Ottenere l'ID risorsa dell'app Europa

Usare il comando az appservice web show per ottenere l'ID risorsa dell'app Web.

$appId = az appservice web show --name $appName --resource-group myResourceGroup --query id --output tsv

Aggiungere un endpoint di Gestione traffico per l'app Europa

Usare il comando az network traffic-manager endpoint create per aggiungere un endpoint al profilo di Gestione traffico e usare l'ID risorsa dell'app Web come destinazione.

az network traffic-manager endpoint create --name myWestEuropeEndpoint --profile-name myTrafficManagerProfile --resource-group myResourceGroup --type azureEndpoints --target-resource-id $appId

Ottenere l'URL dell'endpoint di Gestione traffico

Ora il profilo di Gestione traffico dispone di un endpoint che punta all'app Web esistente. Usare il comando az network traffic-manager profile show per ottenere l'URL.

az network traffic-manager profile show --name myTrafficManagerProfile --resource-group myResourceGroup --query dnsConfig.fqdn --output tsv

Copiare l'output nel browser. Dovrebbe essere visualizzata nuovamente l'app Web.

Creare una cache Redis di Azure in Asia

Ora si vedrà come replicare l'app Web di Azure nell'area Asia sud-orientale. Per iniziare, usare il comando az redis create per creare una seconda cache Redis di Azure in Asia sud-orientale. Questa cache deve disporre di un percorso condiviso con l'app in Asia.

$redis = (az redis create --name $cacheName-asia --resource-group myResourceGroup --location "Southeast Asia" --sku-capacity 0 --sku-family C --sku-name Basic | ConvertFrom-Json)

--name $cacheName-asia fornisce alla cache il nome della cache in Europa occidentale, con il suffisso -asia.

Creare un piano di servizio app in Asia

Usare il comando az appservice plan create per creare un secondo piano di servizio app nell'area Asia sud-orientale, usando il medesimo piano tariffario dell'area Europa occidentale (S1).

az appservice plan create --name myAppServicePlanAsia --resource-group myResourceGroup --location "Southeast Asia" --sku S1

Creare un'app Web in Asia

Usare il comando az appservice web create per creare una seconda app Web.

az appservice web create --name $appName-asia --resource-group myResourceGroup --plan myAppServicePlanAsia

--name $appName-asia fornisce all'app il nome dell'app in Europa occidentale, con il suffisso -asia.

Configurare la stringa di connessione per Redis

Usare il comando az appservice web config appsettings update per aggiungere la stringa di connessione per la cache in Asia sud-orientale all'app Web.

az appservice web config appsettings update --settings "RedisConnection=$($redis.hostname):$($redis.sslPort),password=$($redis.accessKeys.primaryKey),ssl=True,abortConnect=False" --name $appName-asia --resource-group myResourceGroup

Configurare la distribuzione Git per l'app in Asia.

Usare il comando az appservice web source-control config-local-git per configurare la distribuzione Git locale per la seconda app Web.

az appservice web source-control config-local-git --name $appName-asia --resource-group myResourceGroup

Questo comando fornisce un output simile al seguente:

{
  "url": "https://user123@myuniqueappname-asia.scm.azurewebsites.net/myuniqueappname.git"
}

Usare l'URL restituito per configurare un secondo Git remoto per il repository locale. Il comando seguente usa l'esempio di output precedente.

git remote add azure-asia https://user123@myuniqueappname-asia.scm.azurewebsites.net/myuniqueappname.git

Distribuire l'applicazione di esempio

Eseguire git push per distribuire l'applicazione di esempio nel secondo Git remoto.

git push azure-asia master

Quando viene richiesta la password, usare quella specificata all'esecuzione di az appservice web deployment user set.

Passare all'app Asia

Usare il comando az appservice web browse per accertarsi che l'app sia in esecuzione in Azure.

az appservice web browse --name $appName-asia --resource-group myResourceGroup

Ottenere l'ID risorsa dell'app Asia

Usare il comando az appservice web show per ottenere l'ID risorsa dell'app Web in Asia sud-orientale.

$appIdAsia = az appservice web show --name $appName-asia --resource-group myResourceGroup --query id --output tsv

Aggiungere un endpoint di Gestione traffico per l'app Asia

Usare il comando az network traffic-manager endpoint create per aggiungere un secondo endpoint al profilo di Gestione traffico.

az network traffic-manager endpoint create --name myAsiaEndpoint --profile-name myTrafficManagerProfile --resource-group myResourceGroup --type azureEndpoints --target-resource-id $appIdAsia

Aggiungere un identificatore di area alle app Web

Usare il comando az appservice web config appsettings update per aggiungere una variabile di ambiente specifica per l'area.

az appservice web config appsettings update --settings "Region=West Europe" --name $appName --resource-group myResourceGroup
az appservice web config appsettings update --settings "Region=Southeast Asia" --name $appName-asia --resource-group myResourceGroup

Il codice dell'applicazione usa già questa impostazione. Vedere HighScaleApp\Views\Home\Index.cshtml.

Operazione completata

A questo punto, provare ad accedere all'URL del profilo di Gestione traffico da browser in aree geografiche diverse. I browser client situati in Europa dovrebbero mostrare "ASP.NET Europa occidentale", mentre quelli in Asia dovrebbero mostrare "ASP.NET Asia sud-orientale".

Altre risorse