Instradare il traffico Web in base all'URL tramite Azure PowerShell

È possibile usare Azure PowerShell per configurare il routing del traffico Web a pool di server scalabili specifici in base all'URL usato per accedere all'applicazione. In questo articolo viene creato un gateway di app Azure lication con tre pool back-end usando set di scalabilità di macchine virtuali. Ognuno dei pool back-end viene usato per uno scopo specifico, ad esempio dati comuni, immagini e video. Il routing del traffico a pool separati permette ai clienti di ottenere le informazioni necessarie in qualsiasi momento.

Per abilitare il routing del traffico, è necessario creare regole di routing da assegnare ai listener che sono in ascolto su porte specifiche per garantire che il traffico Web arrivi ai server appropriati nei pool.

In questo articolo vengono illustrate le operazioni seguenti:

• Configurare la rete
• Creare i listener, il mapping dei percorsi URL e le regole
• Creare i pool back-end scalabili

Se si preferisce, è possibile completare questa procedura usando l'interfaccia della riga di comando di Azure o il portale di Azure.

Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.

Nota

È consigliabile usare il modulo Azure Az PowerShell per interagire con Azure. Per iniziare, vedere Installare Azure PowerShell. Per informazioni su come eseguire la migrazione al modulo AZ PowerShell, vedere Eseguire la migrazione di Azure PowerShell da AzureRM ad Az.

Azure Cloud Shell

Azure Cloud Shell è un ambiente di shell interattivo ospitato in Azure e usato tramite il browser. È possibile usare Bash o PowerShell con Cloud Shell per usare i servizi di Azure. È possibile usare i comandi preinstallati di Cloud Shell per eseguire il codice in questo articolo, senza dover installare alcun elemento nell'ambiente locale.

Per avviare Azure Cloud Shell:

Opzione	Esempio/Collegamento
Selezionare Prova nell'angolo superiore destro di un codice o di un blocco di comandi. Selezionando Prova non viene copiato automaticamente il codice o il comando in Cloud Shell.
Passare a https://shell.azure.com o selezionare il pulsante Avvia Cloud Shell per aprire Cloud Shell nel browser.
Selezionare il pulsante Cloud Shell nella barra dei menu nell'angolo in alto a destra del portale di Azure.

Per usare Azure Cloud Shell:

1. Avviare Cloud Shell.

2. Selezionare il pulsante Copia in un blocco di codice (o blocco di comandi) per copiare il codice o il comando.

3. Incollare il codice o il comando nella sessione di Cloud Shell selezionando CTRL+MAIUSC+V in Windows e Linux oppure selezionando CMD+MAIUSC+V in macOS.

4. Selezionare INVIO per eseguire il codice o il comando.

Se si sceglie di installare e usare PowerShell in locale, per questo articolo è necessario il modulo Azure PowerShell 1.0.0 o versione successiva. Per trovare la versione, eseguire Get-Module -ListAvailable Az. Se è necessario eseguire l'aggiornamento, vedere Installare e configurare Azure PowerShell. Se si esegue PowerShell in locale, è anche necessario eseguire Login-AzAccount per creare una connessione con Azure.

A causa del tempo necessario per creare risorse, il completamento di questa procedura può richiedere fino a 90 minuti.

Creare un gruppo di risorse

Creare un gruppo di risorse contenente tutte le risorse per l'applicazione.

Creare un gruppo di risorse di Azure usando New-AzResourceGroup.

New-AzResourceGroup -Name myResourceGroupAG -Location eastus

Creare risorse di rete

Che esista già una rete virtuale o se ne crei una nuova, è necessario assicurarsi che contenga una subnet usata solo per i gateway applicazione. In questo articolo viene creata una subnet per il gateway applicazione e una subnet per i set di scalabilità. È necessario creare un indirizzo IP pubblico per consentire l'accesso alle risorse nel gateway applicazione.

Creare le configurazioni di subnet myAGSubnet e myBackendSubnet usando New-AzVirtualNetworkSubnetConfig. Creare la rete virtuale denominata myVNet usando New-AzVirtualNetwork con le configurazioni di subnet. Creare infine l'indirizzo IP pubblico denominato myAGPublicIPAddress con New-AzPublicIpAddress. Queste risorse vengono usate per fornire la connettività di rete al gateway applicazione e alle risorse associate.

$backendSubnetConfig = New-AzVirtualNetworkSubnetConfig `
  -Name myBackendSubnet `
  -AddressPrefix 10.0.1.0/24

$agSubnetConfig = New-AzVirtualNetworkSubnetConfig `
  -Name myAGSubnet `
  -AddressPrefix 10.0.2.0/24

$vnet = New-AzVirtualNetwork `
  -ResourceGroupName myResourceGroupAG `
  -Location eastus `
  -Name myVNet `
  -AddressPrefix 10.0.0.0/16 `
  -Subnet $backendSubnetConfig, $agSubnetConfig
$pip = New-AzPublicIpAddress `
  -ResourceGroupName myResourceGroupAG `
  -Location eastus `
  -Name myAGPublicIPAddress `
  -AllocationMethod Static `
  -Sku Standard

Creare un gateway applicazione

In questa sezione verranno create risorse che supportano il gateway applicazione e infine verrà creato quest'ultimo. Le risorse create includono:

• Configurazioni IP e porta front-end: associa la subnet creata in precedenza al gateway applicazione e assegna una porta da usare per accedervi.
• Pool predefinito: tutti i gateway applicazione devono avere almeno un pool back-end di server.
• Listener e regola predefiniti: il listener predefinito è in ascolto del traffico sulla porta assegnata e la regola predefinita invia il traffico al pool predefinito.

Creare le configurazioni IP e la porta front-end

Associare myAGSubnet creato in precedenza al gateway applicazione usando New-AzApplicationGatewayIPConfiguration. Assegnare myAGPublicIPAddress al gateway applicazione usando New-AzApplicationGatewayFrontendIPConfig.

$vnet = Get-AzVirtualNetwork `
  -ResourceGroupName myResourceGroupAG `
  -Name myVNet

$subnet=$vnet.Subnets[0]

$pip = Get-AzPublicIpAddress `
  -ResourceGroupName myResourceGroupAG `
  -Name myAGPublicIPAddress

$gipconfig = New-AzApplicationGatewayIPConfiguration `
  -Name myAGIPConfig `
  -Subnet $subnet

$fipconfig = New-AzApplicationGatewayFrontendIPConfig `
  -Name myAGFrontendIPConfig `
  -PublicIPAddress $pip

$frontendport = New-AzApplicationGatewayFrontendPort `
  -Name myFrontendPort `
  -Port 80

Creare il pool predefinito e le impostazioni

Creare il pool back-end predefinito denominato appGatewayBackendPool per il gateway applicazione usando New-AzApplicationGatewayBackendAddressPool. Configurare le impostazioni per il pool back-end usando New-AzApplicationGatewayBackendHttpSetting.

$defaultPool = New-AzApplicationGatewayBackendAddressPool `
  -Name appGatewayBackendPool

$poolSettings = New-AzApplicationGatewayBackendHttpSetting `
  -Name myPoolSettings `
  -Port 80 `
  -Protocol Http `
  -CookieBasedAffinity Enabled `
  -RequestTimeout 120

Creare il listener predefinito e la regola

È necessario un listener per consentire al gateway applicazione di instradare il traffico in modo appropriato al pool back-end. In questo articolo vengono creati due listener. Il primo listener di base creato è in ascolto del traffico nell'URL radice. Il secondo listener creato è in ascolto del traffico in URL specifici.

Creare il listener predefinito denominato myDefaultListener usando New-AzApplicationGatewayHttpListener con la configurazione front-end e la porta front-end creata in precedenza.

È necessaria una regola per comunicare al listener quale pool back-end usare per il traffico in ingresso. Creare una regola di base denominata rule1 usando New-AzApplicationGatewayRequestRoutingRule.

$defaultlistener = New-AzApplicationGatewayHttpListener `
  -Name myDefaultListener `
  -Protocol Http `
  -FrontendIPConfiguration $fipconfig `
  -FrontendPort $frontendport

$frontendRule = New-AzApplicationGatewayRequestRoutingRule `
  -Name rule1 `
  -RuleType Basic `
  -HttpListener $defaultlistener `
  -BackendAddressPool $defaultPool `
  -BackendHttpSettings $poolSettings

Creare il gateway applicazione

Ora che sono state create le risorse di supporto necessarie, specificare i parametri per il gateway applicazione denominato myAppGateway usando New-AzApplicationGatewaySku e quindi crearlo usando New-AzApplicationGateway.

$sku = New-AzApplicationGatewaySku `
  -Name Standard_v2 `
  -Tier Standard_v2 `
  -Capacity 2

$appgw = New-AzApplicationGateway `
  -Name myAppGateway `
  -ResourceGroupName myResourceGroupAG `
  -Location eastus `
  -BackendAddressPools $defaultPool `
  -BackendHttpSettingsCollection $poolSettings `
  -FrontendIpConfigurations $fipconfig `
  -GatewayIpConfigurations $gipconfig `
  -FrontendPorts $frontendport `
  -HttpListeners $defaultlistener `
  -RequestRoutingRules $frontendRule `
  -Sku $sku

La creazione del gateway applicazione può richiedere fino a 30 minuti. Attendere fino al termine della distribuzione prima di passare alla sezione successiva.

A questo punto, si dispone di un gateway applicazione che resta in ascolto del traffico sulla porta 80 e lo invia a un pool di server predefinito.

Aggiungere i pool back-end di immagini e video e la porta

Aggiungere pool back-end denominati imagesBackendPool e videoBackendPool al gateway applicazione usando Add-AzApplicationGatewayBackendAddressPool. Aggiungere la porta front-end per i pool usando Add-AzApplicationGatewayFrontendPort. Inviare le modifiche al gateway applicazione usando Set-AzApplicationGateway.

$appgw = Get-AzApplicationGateway `
  -ResourceGroupName myResourceGroupAG `
  -Name myAppGateway

Add-AzApplicationGatewayBackendAddressPool `
  -ApplicationGateway $appgw `
  -Name imagesBackendPool

Add-AzApplicationGatewayBackendAddressPool `
  -ApplicationGateway $appgw `
  -Name videoBackendPool

Add-AzApplicationGatewayFrontendPort `
  -ApplicationGateway $appgw `
  -Name bport `
  -Port 8080

Set-AzApplicationGateway -ApplicationGateway $appgw

Il completamento dell'aggiornamento del gateway applicazione può richiedere fino a 20 minuti.

Aggiungere il listener back-end

Aggiungere il listener back-end denominato backendListener necessario per instradare il traffico usando Add-AzApplicationGatewayHttpListener.

$appgw = Get-AzApplicationGateway `
  -ResourceGroupName myResourceGroupAG `
  -Name myAppGateway

$backendPort = Get-AzApplicationGatewayFrontendPort `
  -ApplicationGateway $appgw `
  -Name bport

$fipconfig = Get-AzApplicationGatewayFrontendIPConfig `
  -ApplicationGateway $appgw

Add-AzApplicationGatewayHttpListener `
  -ApplicationGateway $appgw `
  -Name backendListener `
  -Protocol Http `
  -FrontendIPConfiguration $fipconfig `
  -FrontendPort $backendPort

Set-AzApplicationGateway -ApplicationGateway $appgw

Aggiungere la mappa di percorso URL

I mapping dei percorsi URL garantiscono che gli URL inviati all'applicazione vengano instradati a pool back-end specifici. Creare i mapping dei percorsi URL denominati imagePathRule e videoPathRule usando New-AzApplicationGatewayPathRuleConfig e Add-AzApplicationGatewayUrlPathMapConfig.

$appgw = Get-AzApplicationGateway `
  -ResourceGroupName myResourceGroupAG `
  -Name myAppGateway

$poolSettings = Get-AzApplicationGatewayBackendHttpSetting `
  -ApplicationGateway $appgw `
  -Name myPoolSettings

$imagePool = Get-AzApplicationGatewayBackendAddressPool `
  -ApplicationGateway $appgw `
  -Name imagesBackendPool

$videoPool = Get-AzApplicationGatewayBackendAddressPool `
  -ApplicationGateway $appgw `
  -Name videoBackendPool

$defaultPool = Get-AzApplicationGatewayBackendAddressPool `
  -ApplicationGateway $appgw `
  -Name appGatewayBackendPool

$imagePathRule = New-AzApplicationGatewayPathRuleConfig `
  -Name imagePathRule `
  -Paths "/images/*" `
  -BackendAddressPool $imagePool `
  -BackendHttpSettings $poolSettings

$videoPathRule = New-AzApplicationGatewayPathRuleConfig `
  -Name videoPathRule `
    -Paths "/video/*" `
    -BackendAddressPool $videoPool `
    -BackendHttpSettings $poolSettings

Add-AzApplicationGatewayUrlPathMapConfig `
  -ApplicationGateway $appgw `
  -Name urlpathmap `
  -PathRules $imagePathRule, $videoPathRule `
  -DefaultBackendAddressPool $defaultPool `
  -DefaultBackendHttpSettings $poolSettings

Set-AzApplicationGateway -ApplicationGateway $appgw

Aggiungere la regola di routing

La regola di routing associa la mappa URL al listener creato. Aggiungere la regola denominata rule2 usando Add-AzApplicationGatewayRequestRoutingRule.

$appgw = Get-AzApplicationGateway `
  -ResourceGroupName myResourceGroupAG `
  -Name myAppGateway

$backendlistener = Get-AzApplicationGatewayHttpListener `
  -ApplicationGateway $appgw `
  -Name backendListener

$urlPathMap = Get-AzApplicationGatewayUrlPathMapConfig `
  -ApplicationGateway $appgw `
  -Name urlpathmap

Add-AzApplicationGatewayRequestRoutingRule `
  -ApplicationGateway $appgw `
  -Name rule2 `
  -RuleType PathBasedRouting `
  -HttpListener $backendlistener `
  -UrlPathMap $urlPathMap

Set-AzApplicationGateway -ApplicationGateway $appgw

Creare set di scalabilità di macchine virtuali

In questo esempio si creano tre set di scalabilità di macchine virtuali che supportano i tre pool back-end creati. I set di scalabilità creati sono denominati myvmss1, myvmss2 e myvmss3. Il set di scalabilità viene assegnato al pool back-end quando si configurano le impostazioni IP.

$vnet = Get-AzVirtualNetwork `
  -ResourceGroupName myResourceGroupAG `
  -Name myVNet

$appgw = Get-AzApplicationGateway `
  -ResourceGroupName myResourceGroupAG `
  -Name myAppGateway

$backendPool = Get-AzApplicationGatewayBackendAddressPool `
  -Name appGatewayBackendPool `
  -ApplicationGateway $appgw

$imagesPool = Get-AzApplicationGatewayBackendAddressPool `
  -Name imagesBackendPool `
  -ApplicationGateway $appgw

$videoPool = Get-AzApplicationGatewayBackendAddressPool `
  -Name videoBackendPool `
  -ApplicationGateway $appgw

for ($i=1; $i -le 3; $i++)
{
  if ($i -eq 1)
  {
     $poolId = $backendPool.Id
  }
  if ($i -eq 2) 
  {
    $poolId = $imagesPool.Id
  }
  if ($i -eq 3)
  {
    $poolId = $videoPool.Id
  }

  $ipConfig = New-AzVmssIpConfig `
    -Name myVmssIPConfig$i `
    -SubnetId $vnet.Subnets[1].Id `
    -ApplicationGatewayBackendAddressPoolsId $poolId

  $vmssConfig = New-AzVmssConfig `
    -Location eastus `
    -SkuCapacity 2 `
    -SkuName Standard_DS2_v2 `
    -UpgradePolicyMode Automatic

  Set-AzVmssStorageProfile $vmssConfig `
    -ImageReferencePublisher MicrosoftWindowsServer `
    -ImageReferenceOffer WindowsServer `
    -ImageReferenceSku 2016-Datacenter `
    -ImageReferenceVersion latest `
    -OsDiskCreateOption FromImage

  Set-AzVmssOsProfile $vmssConfig `
    -AdminUsername azureuser `
    -AdminPassword "Azure123456!" `
    -ComputerNamePrefix myvmss$i

  Add-AzVmssNetworkInterfaceConfiguration `
    -VirtualMachineScaleSet $vmssConfig `
    -Name myVmssNetConfig$i `
    -Primary $true `
    -IPConfiguration $ipConfig

  New-AzVmss `
    -ResourceGroupName myResourceGroupAG `
    -Name myvmss$i `
    -VirtualMachineScaleSet $vmssConfig
}

Installare IIS

Ogni set di scalabilità contiene due istanze di macchina virtuale in cui si installa IIS. Viene creata una pagina di esempio per verificare se il gateway applicazione funziona.

$publicSettings = @{ "fileUris" = (,"https://raw.githubusercontent.com/Azure/azure-docs-powershell-samples/master/application-gateway/iis/appgatewayurl.ps1"); 
  "commandToExecute" = "powershell -ExecutionPolicy Unrestricted -File appgatewayurl.ps1" }

for ($i=1; $i -le 3; $i++)
{
  $vmss = Get-AzVmss -ResourceGroupName myResourceGroupAG -VMScaleSetName myvmss$i
  Add-AzVmssExtension -VirtualMachineScaleSet $vmss `
    -Name "customScript" `
    -Publisher "Microsoft.Compute" `
    -Type "CustomScriptExtension" `
    -TypeHandlerVersion 1.8 `
    -Setting $publicSettings

  Update-AzVmss `
    -ResourceGroupName myResourceGroupAG `
    -Name myvmss$i `
    -VirtualMachineScaleSet $vmss
}

Testare il gateway applicazione

Usare Get-AzPublicIPAddress per ottenere l'indirizzo IP pubblico del gateway applicazione. Copiare l'indirizzo IP pubblico e quindi incollarlo nella barra degli indirizzi del browser. Ad esempio http://52.168.55.24, http://52.168.55.24:8080/images/test.htm o http://52.168.55.24:8080/video/test.htm.

Get-AzPublicIPAddress -ResourceGroupName myResourceGroupAG -Name myAGPublicIPAddress

Modificare l'URL in http://< ip-address>:8080/images/test.htm, sostituendo l'indirizzo IP per <ip-address> e verrà visualizzato un codice simile all'esempio seguente:

Modificare l'URL in http://< ip-address>:8080/video/test.htm, sostituendo l'indirizzo IP per <ip-address> e verrà visualizzato un codice simile all'esempio seguente:

Pulire le risorse

Quando non sono più necessari, rimuovere il gruppo di risorse, il gateway applicazione e tutte le risorse correlate usando Remove-AzResourceGroup.

Remove-AzResourceGroup -Name myResourceGroupAG

Passaggi successivi

Reindirizzare il traffico Web in base all'URL