Condividi tramite

Creare un gateway applicazione con reindirizzamento basato su percorsi URL usando Azure PowerShell

È possibile usare Azure PowerShell per configurare regole di routing basato su URL quando si crea un gateway applicazione. In questa esercitazione si creano pool back-end usando i set di scalabilità di macchine virtuali. Si creano quindi regole di routing URL che reindirizzano il traffico Web al pool back-end appropriato in base al percorso URL della richiesta. È possibile usare Azure PowerShell per configurare regole di routing avanzate basate su URL quando si crea un gateway applicazione.

Questa esercitazione illustra le configurazioni pronte per la produzione, incluse le procedure consigliate per la sicurezza, l'ottimizzazione delle prestazioni e la configurazione del monitoraggio.

In questa esercitazione si apprenderà come:

  • Configurare l'infrastruttura di rete
  • Creare un gateway per applicazioni con instradamento basato sul percorso
  • Aggiungere listener e regole di routing per il reindirizzamento url
  • Creare set di scalabilità di macchine virtuali per i pool back-end
  • Testare la funzionalità di routing e reindirizzamento del gateway dell'applicazione

L'esempio seguente illustra il traffico del sito in arrivo dalle porte 8080 e 8081 e indirizzato agli stessi pool back-end:

Diagramma dell'architettura di routing e reindirizzamento degli URL.

Prerequisiti

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

Prima di iniziare questa esercitazione, assicurarsi di disporre di:

  • Una sottoscrizione di Azure attiva. Crea un account gratuito se non ne hai uno.
  • Modulo Azure PowerShell versione 5.4.1 o successiva installato in locale oppure accesso ad Azure Cloud Shell
  • Autorizzazioni di Collaboratore o Proprietario sulla sottoscrizione Azure di destinazione
  • Conoscenza di base dei concetti relativi al gateway dell'applicazione e degli script di PowerShell

Note

È consigliabile utilizzare 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 contenuto in questo articolo senza dover installare strumenti nell'ambiente locale.

Per avviare Azure Cloud Shell:

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

Per usare Azure Cloud Shell:

  1. Avviare Cloud Shell.

  2. Selezionare il pulsante Copia in un blocco di codice (o in un blocco di comando) 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 o selezionando CMD+MAIUSC+V in macOS.

  4. Premere Invio per eseguire il codice o il comando.

Se si sceglie di installare e usare PowerShell in locale, questa esercitazione richiede il modulo Azure PowerShell versione 5.4.1 o 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 Connect-AzAccount per creare una connessione con Azure.

Creare un gruppo di risorse

Un gruppo di risorse è un contenitore logico in cui le risorse di Azure vengono distribuite e gestite. Creare un gruppo di risorse di Azure usando New-AzResourceGroup.

# Define variables for consistent naming and easier management
$resourceGroupName = "myResourceGroupAG"
$location = "eastus"

# Create the resource group
New-AzResourceGroup -Name $resourceGroupName -Location $location

# Verify the resource group creation
Write-Output "Resource group '$resourceGroupName' created successfully in '$location'"

Creare risorse di rete

Creare le configurazioni di subnet per myBackendSubnet e myAGSubnet 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 usando New-AzPublicIpAddress. Queste risorse forniscono la connettività di rete al gateway dell'applicazione e alle risorse associate.

Importante

La subnet del gateway applicazione (myAGSubnet) può contenere solo i gateway applicazione. In questa subnet non sono consentite altre risorse. Creare le configurazioni di subnet per myBackendSubnet e myAGSubnet usando New-AzVirtualNetworkSubnetConfig. Il gateway applicativo richiede una subnet dedicata con un minimo di /24 CIDR per il corretto funzionamento e la scalabilità futura. Creare la rete virtuale denominata myVNet usando New-AzVirtualNetwork con le configurazioni di subnet. Infine, creare l'indirizzo IP pubblico con SKU Standard e allocazione statica per migliorare la sicurezza e le prestazioni usando New-AzPublicIpAddress.

# Create backend subnet configuration with appropriate CIDR for scale sets
$backendSubnetConfig = New-AzVirtualNetworkSubnetConfig `
  -Name myBackendSubnet `
  -AddressPrefix 10.0.1.0/24

# Create Application Gateway subnet - dedicated subnet required
$agSubnetConfig = New-AzVirtualNetworkSubnetConfig `
  -Name myAGSubnet `
  -AddressPrefix 10.0.2.0/24

New-AzVirtualNetwork `
  -ResourceGroupName myResourceGroupAG `
  -Location eastus `
  -Name myVNet `
  -AddressPrefix 10.0.0.0/16 `
  -Subnet $backendSubnetConfig, $agSubnetConfig

New-AzPublicIpAddress `
  -ResourceGroupName myResourceGroupAG `
  -Location eastus `
  -Name myAGPublicIPAddress `
  -AllocationMethod Dynamic

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:per associare la subnet creata in precedenza al gateway applicazione e assegnare 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 la subnet myAGSubnet creata in precedenza al gateway applicazione usando New-AzApplicationGatewayIPConfiguration. Assegnare myAGPublicIPAddress al gateway applicazione usando New-AzApplicationGatewayFrontendIPConfig. Creare quindi la porta HTTP usando New-AzApplicationGatewayFrontendPort.

# Get the virtual network and subnet references
$vnet = Get-AzVirtualNetwork `
  -ResourceGroupName myResourceGroupAG `
  -Name myVNet

$subnet=$vnet.Subnets[0]

# Get the public IP address
$pip = Get-AzPublicIpAddress `
  -ResourceGroupName myResourceGroupAG `
  -Name myAGPublicIPAddress

# Create IP configuration for the Application Gateway
$gipconfig = New-AzApplicationGatewayIPConfiguration `
  -Name myAGIPConfig `
  -Subnet $subnet

# Create frontend IP configuration
$fipconfig = New-AzApplicationGatewayFrontendIPConfig `
  -Name myAGFrontendIPConfig `
  -PublicIPAddress $pip

# Create frontend port for HTTP traffic
$frontendport = New-AzApplicationGatewayFrontendPort `
  -Name myFrontendPort `
  -Port 80

Write-Output "Application Gateway IP configurations created successfully"

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-AzApplicationGatewayBackendHttpSettings.

# Create default backend pool
$defaultPool = New-AzApplicationGatewayBackendAddressPool `
  -Name appGatewayBackendPool

# Create backend HTTP settings with optimized configuration
$poolSettings = New-AzApplicationGatewayBackendHttpSettings `
  -Name myPoolSettings `
  -Port 80 `
  -Protocol Http `
  -CookieBasedAffinity Enabled `
  -RequestTimeout 120

Creare il listener predefinito e la regola

È necessario un listener per consentire al gateway applicativo di instradare il traffico in modo appropriato ai pool di backend. In questa esercitazione vengono creati più listener per diversi scenari di routing. Il primo listener di base prevede il traffico all'URL radice. Gli altri listener prevedono il traffico in percorsi URL specifici, ad esempio http://203.0.113.1:8080/images/ o http://203.0.113.1:8081/video/.

Creare un listener denominato defaultListener usando New-AzApplicationGatewayHttpListener con la configurazione front-end e la porta front-end create 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.

# Create default HTTP listener
$defaultlistener = New-AzApplicationGatewayHttpListener `
  -Name defaultListener `
  -Protocol Http `
  -FrontendIPConfiguration $fipconfig `
  -FrontendPort $frontendport

# Create basic routing rule that directs traffic to default pool
$frontendRule = New-AzApplicationGatewayRequestRoutingRule `
  -Name rule1 `
  -RuleType Basic `
  -HttpListener $defaultlistener `
  -BackendAddressPool $defaultPool `
  -BackendHttpSettings $poolSettings `
  -Priority 100

Write-Output "Default listener and routing rule created successfully"

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.

# Create SKU configuration for Application Gateway v2
$sku = New-AzApplicationGatewaySku `
  -Name Standard_Medium `
  -Tier Standard `
  -Capacity 2

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

Aggiunta di pool back-end e porte

È possibile aggiungere pool di back-end al gateway dell'applicazione usando Add-AzApplicationGatewayBackendAddressPool. In questo esempio vengono create immaginiBackendPool e videoBackendPool per il routing di tipi di contenuto specifici. È possibile aggiungere porte front-end per i pool usando Add-AzApplicationGatewayFrontendPort. Invia le modifiche al gateway di applicazioni usando Set-AzApplicationGateway.

# Get the current Application Gateway configuration
$appgw = Get-AzApplicationGateway `
  -ResourceGroupName myResourceGroupAG `
  -Name myAppGateway

# Add specialized backend pools for different content types
Add-AzApplicationGatewayBackendAddressPool `
  -ApplicationGateway $appgw `
  -Name imagesBackendPool

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

# Add frontend ports for specialized listeners
Add-AzApplicationGatewayFrontendPort `
  -ApplicationGateway $appgw `
  -Name bport `
  -Port 8080

Add-AzApplicationGatewayFrontendPort `
  -ApplicationGateway $appgw `
  -Name rport `
  -Port 8081

# Apply the configuration changes
Set-AzApplicationGateway -ApplicationGateway $appgw

Aggiungere listener e regole

Aggiungere i listener

Aggiungere i listener denominati backendListener e redirectedListener necessari per instradare il traffico usando Add-AzApplicationGatewayHttpListener.

# Get the current Application Gateway configuration
$appgw = Get-AzApplicationGateway `
  -ResourceGroupName myResourceGroupAG `
  -Name myAppGateway

# Get frontend port references
$backendPort = Get-AzApplicationGatewayFrontendPort `
  -ApplicationGateway $appgw `
  -Name bport

$redirectPort = Get-AzApplicationGatewayFrontendPort `
  -ApplicationGateway $appgw `
  -Name rport

# Get frontend IP configuration
$fipconfig = Get-AzApplicationGatewayFrontendIPConfig `
  -ApplicationGateway $appgw

# Add listeners for different ports
Add-AzApplicationGatewayHttpListener `
  -ApplicationGateway $appgw `
  -Name backendListener `
  -Protocol Http `
  -FrontendIPConfiguration $fipconfig `
  -FrontendPort $backendPort

Add-AzApplicationGatewayHttpListener `
  -ApplicationGateway $appgw `
  -Name redirectedListener `
  -Protocol Http `
  -FrontendIPConfiguration $fipconfig `
  -FrontendPort $redirectPort

# Apply the configuration changes
Set-AzApplicationGateway -ApplicationGateway $appgw

Aggiunta della mappa del percorso URL predefinito

I mapping dei percorsi URL garantiscono che URL specifici vengano instradati a determinati pool back-end. È possibile creare mappe di percorsi URL denominate imagePathRule e videoPathRule usando New-AzApplicationGatewayPathRuleConfig e Add-AzApplicationGatewayUrlPathMapConfig.

# Get the current Application Gateway configuration
$appgw = Get-AzApplicationGateway `
  -ResourceGroupName myResourceGroupAG `
  -Name myAppGateway

# Get backend HTTP settings
$poolSettings = Get-AzApplicationGatewayBackendHttpSettings `
  -ApplicationGateway $appgw `
  -Name myPoolSettings

# Get backend address pools
$imagePool = Get-AzApplicationGatewayBackendAddressPool `
  -ApplicationGateway $appgw `
  -Name imagesBackendPool

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

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

# Create path rules for different content types
$imagePathRule = New-AzApplicationGatewayPathRuleConfig `
  -Name imagePathRule `
  -Paths "/images/*" `
  -BackendAddressPool $imagePool `
  -BackendHttpSettings $poolSettings

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

# Add URL path map configuration
Add-AzApplicationGatewayUrlPathMapConfig `
  -ApplicationGateway $appgw `
  -Name urlpathmap `
  -PathRules $imagePathRule, $videoPathRule `
  -DefaultBackendAddressPool $defaultPool `
  -DefaultBackendHttpSettings $poolSettings

# Apply the configuration changes
Set-AzApplicationGateway -ApplicationGateway $appgw

Aggiunta della configurazione di reindirizzamento

È possibile configurare il reindirizzamento per il listener usando Add-AzApplicationGatewayRedirectConfiguration.

# Get the current Application Gateway configuration
$appgw = Get-AzApplicationGateway `
  -ResourceGroupName $resourceGroupName `
  -Name myAppGateway

# Get the target listener for redirection
$backendListener = Get-AzApplicationGatewayHttpListener `
  -ApplicationGateway $appgw `
  -Name backendListener

# Add redirection configuration with query string and path preservation
$redirectConfig = Add-AzApplicationGatewayRedirectConfiguration `
  -ApplicationGateway $appgw `
  -Name redirectConfig `
  -RedirectType Found `
  -TargetListener $backendListener `
  -IncludePath $true `
  -IncludeQueryString $true

# Apply the configuration changes
Set-AzApplicationGateway -ApplicationGateway $appgw

Write-Output "Redirection configuration added successfully"
Write-Output "Redirect type: HTTP 302 Found"
Write-Output "Target: backendListener (Port 8080)"
Write-Output "Preserves: Path and Query String"

Aggiunta della mappa del percorso URL di reindirizzamento

Creare una mappa percorso URL separata per gli scenari di reindirizzamento. Questa mappa gestirà il traffico sulla porta 8081 e reindirizzerà percorsi specifici al listener appropriato sulla porta 8080.

# Get the current Application Gateway configuration
$appgw = Get-AzApplicationGateway `
  -ResourceGroupName $resourceGroupName `
  -Name myAppGateway

# Get references to existing configurations
$poolSettings = Get-AzApplicationGatewayBackendHttpSettings `
  -ApplicationGateway $appgw `
  -Name myPoolSettings

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

$redirectConfig = Get-AzApplicationGatewayRedirectConfiguration `
  -ApplicationGateway $appgw `
  -Name redirectConfig

# Create path rule for redirection - images traffic will be redirected
$redirectPathRule = New-AzApplicationGatewayPathRuleConfig `
  -Name redirectPathRule `
  -Paths "/images/*" `
  -RedirectConfiguration $redirectConfig

# Add redirection path map configuration
Add-AzApplicationGatewayUrlPathMapConfig `
  -ApplicationGateway $appgw `
  -Name redirectpathmap `
  -PathRules $redirectPathRule `
  -DefaultBackendAddressPool $defaultPool `
  -DefaultBackendHttpSettings $poolSettings

# Apply the configuration changes
Set-AzApplicationGateway -ApplicationGateway $appgw

Write-Output "Redirection URL path map added successfully"
Write-Output "Redirection rule: /images/* on port 8081 -> port 8080"

Aggiungere le regole di routing

Le regole di routing associano le mappe URL ai listener creati. È possibile aggiungere le regole denominate defaultRule e redirectedRule usando Add-AzApplicationGatewayRequestRoutingRule.

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

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

$redirectlistener = Get-AzApplicationGatewayHttpListener `
  -ApplicationGateway $appgw `
  -Name redirectedListener

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

$redirectPathMap = Get-AzApplicationGatewayUrlPathMapConfig `
  -ApplicationGateway $appgw `
  -Name redirectpathmap

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

Add-AzApplicationGatewayRequestRoutingRule `
  -ApplicationGateway $appgw `
  -Name redirectedRule `
  -RuleType PathBasedRouting `
  -HttpListener $redirectlistener `
  -UrlPathMap $redirectPathMap

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à sono denominati myvmss1, myvmss2 e myvmss3. Ogni set di scalabilità contiene due istanze di macchina virtuale in cui si installa IIS. Il set di scalabilità viene assegnato al pool back-end quando si configurano le impostazioni IP.

Importante

Sostituire <username> e <password> con i propri valori prima di eseguire lo script. Usare una password complessa che soddisfi i requisiti di sicurezza di Azure. Nota sulla sicurezza: sostituire <username> e <password> con credenziali sicure. Prendere in considerazione l'uso di Azure Key Vault per la gestione delle credenziali negli scenari di produzione.

# Get network and Application Gateway references
$vnet = Get-AzVirtualNetwork `
  -ResourceGroupName myResourceGroupAG `
  -Name myVNet

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

# Get backend pool references
$backendPool = Get-AzApplicationGatewayBackendAddressPool `
  -Name appGatewayBackendPool `
  -ApplicationGateway $appgw

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

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

# Create three scale sets with improved configuration
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

  # Create scale set configuration with modern VM size and settings
  $vmssConfig = New-AzVmssConfig `
    -Location eastus `
    -SkuCapacity 2 `
    -SkuName Standard_DS2 `
    -UpgradePolicyMode Automatic

  # Configure storage profile with Windows Server 2022
  Set-AzVmssStorageProfile $vmssConfig `
    -ImageReferencePublisher MicrosoftWindowsServer `
    -ImageReferenceOffer WindowsServer `
    -ImageReferenceSku 2016-Datacenter `
    -ImageReferenceVersion latest `
    -OsDiskCreateOption FromImage

  Set-AzVmssOsProfile $vmssConfig `
    -AdminUsername <username> `
    -AdminPassword "<password>" `
    -ComputerNamePrefix myvmss$i

  # Add network interface configuration
  Add-AzVmssNetworkInterfaceConfiguration `
    -VirtualMachineScaleSet $vmssConfig `
    -Name myVmssNetConfig$i `
    -Primary $true `
    -IPConfiguration $ipConfig

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

  Write-Output "Virtual Machine Scale Set myvmss$i created successfully"
}

Write-Output "All Virtual Machine Scale Sets created successfully"

Installare IIS

Lo script seguente installa IIS nelle macchine virtuali in ogni set di scalabilità e li configura per visualizzare contenuti diversi in base al pool back-end usato.

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

# Install IIS on all scale sets
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

Anche se IIS non è necessario per creare il gateway applicativo, lo hai installato in questa esercitazione per verificare se Azure ha creato correttamente il gateway applicativo. Usare IIS per testare il gateway applicazione:

  1. Eseguire Get-AzPublicIPAddress per ottenere l'indirizzo IP pubblico del gateway dell'applicazione.

    Get-AzPublicIPAddress -ResourceGroupName myResourceGroupAG -Name myAGPublicIPAddress

  2. Copiare l'indirizzo IP pubblico e quindi incollarlo nella barra degli indirizzi del browser. Per esempio:

    • http://203.0.113.1 (URL di base)
    • http://203.0.113.1:8080/images/test.htm (percorso immagini)
    • http://203.0.113.1:8080/video/test.htm (percorso del video)
    • http://203.0.113.1:8081/images/test.htm (test di reindirizzamento)

Screenshot che mostra la pagina iniziale predefinita di IIS durante il test dell'URL base del gateway di applicazione.

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:

Screenshot che mostra la pagina di test del pool backend delle immagini quando si accede al percorso /images nel gateway dell'applicazione.

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:

Screenshot che mostra la pagina di test del pool back-end video durante l'accesso al percorso /video nel gateway applicazione.

A questo punto, modificare l'URL in http://<ip-address>:8081/images/test.htm, sostituendo l'indirizzo IP con <ip-address> e verrà visualizzato il traffico reindirizzato al pool back-end delle immagini in http://<ip-address>:8080/images.

Monitoraggio delle prestazioni

Monitorare le metriche chiave dell'Application Gateway per ottenere prestazioni ottimali.

  • Conteggio richieste: numero totale di richieste elaborate
  • Tempo di risposta: tempo medio di risposta per le richieste
  • Numero host non integro: numero di server back-end non integri
  • Velocità effettiva: velocità di trasferimento dei dati tramite il Gateway Applicativo

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

Dopo aver appreso il reindirizzamento basato sul percorso URL con l'Application Gateway, esplora questi scenari avanzati:

Altre informazioni sulle caratteristiche e le funzionalità del gateway applicativo

Configurare la terminazione SSL con il gateway applicazione

Implementare criteri del Firewall per Applicazioni Web (WAF)

Configurare Application Gateway con Azure Container Instances

Altre risorse

  • Last updated on