Partilhar via

Criar um gateway de aplicativo com redirecionamento baseado em caminho de URL usando o Azure PowerShell

Você pode usar o Azure PowerShell para configurar regras de roteamento baseadas em URL ao criar um gateway de aplicativo. Neste tutorial, irá criar grupos de back-end através de conjuntos de dimensionamento de máquinas virtuais. Em seguida, você cria regras de roteamento de URL que redirecionam o tráfego da Web para o pool de back-end apropriado com base no caminho da URL da solicitação. Você pode usar o Azure PowerShell para configurar regras avançadas de roteamento baseadas em URL ao criar um gateway de aplicativo.

Este tutorial aborda configurações prontas para produção, incluindo práticas recomendadas de segurança, otimização de desempenho e configuração de monitoramento.

Neste tutorial, aprenderás como:

  • Configurar a infraestrutura de rede
  • Criar um gateway de aplicação com encaminhamento baseado em percurso
  • Adicionar ouvintes e regras de roteamento para redirecionamento de URL
  • Criar conjuntos de dimensionamento de máquinas virtuais para grupos de back-end.
  • Testar a funcionalidade de roteamento e redirecionamento do gateway de aplicativo

O exemplo seguinte mostra o tráfego do site proveniente das portas 8080 e 8081 e que está a ser direcionado para os mesmos conjuntos de back-end:

Diagrama da arquitetura de roteamento e redirecionamento de URL.

Pré-requisitos

Se preferir, você pode concluir este procedimento usando a CLI do Azure.

Antes de começar este tutorial, certifique-se de:

  • Uma assinatura ativa do Azure. Crie uma conta gratuita se não tiver uma.
  • Módulo do Azure PowerShell versão 5.4.1 ou posterior instalado localmente ou acesso ao Azure Cloud Shell
  • Permissões de Colaborador ou Proprietário na subscrição do Azure de destino
  • Uma compreensão básica dos conceitos do Application Gateway e dos scripts do PowerShell

Observação

Recomendamos que utilize o módulo Azure Az PowerShell para interagir com o Azure. Para começar, veja Install Azure PowerShell. Para saber como migrar para o módulo Az PowerShell, veja Migrate Azure PowerShell from AzureRM to Az.

Azure Cloud Shell

O Azure hospeda o Azure Cloud Shell, um ambiente de shell interativo que você pode usar por meio do navegador. Você pode usar o Bash ou o PowerShell com o Cloud Shell para trabalhar com os serviços do Azure. Você pode usar os comandos pré-instalados do Cloud Shell para executar o código neste artigo, sem precisar instalar nada em seu ambiente local.

Para iniciar o Azure Cloud Shell:

Opção Exemplo/Ligação
Selecione Experimentar no canto superior direito de um código ou bloco de comandos. Selecionar Experimentar não copia automaticamente o código ou comando para o Cloud Shell. Captura de tela que mostra um exemplo de Try It for Azure Cloud Shell.
Vá para https://shell.azure.com, ou selecione o botão Iniciar o Cloud Shell para abrir o Cloud Shell no navegador. botão para iniciar o Azure Cloud Shell.
Selecione o botão Cloud Shell na barra de menus no canto superior direito do portal do Azure. Captura de tela que mostra o botão Cloud Shell no portal do Azure

Para usar o Azure Cloud Shell:

  1. Inicie o Cloud Shell.

  2. Selecione o botão Copiar em um bloco de código (ou bloco de comando) para copiar o código ou comando.

  3. Cole o código ou comando na sessão do Cloud Shell selecionando Ctrl+Shift+V no Windows e Linux ou selecionando Cmd+Shift+V no macOS.

  4. Selecione Enter para executar o código ou comando.

Se você optar por instalar e usar o PowerShell localmente, este tutorial exigirá o módulo do Azure PowerShell versão 5.4.1 ou posterior. Para localizar a versão, execute Get-Module -ListAvailable Az. Se você precisar atualizar, consulte Instalar o módulo do Azure PowerShell. Se você estiver executando o PowerShell localmente, também precisará executar Connect-AzAccount para criar uma conexão com o Azure.

Criar um grupo de recursos

Um grupo de recursos é um contêiner lógico no qual os recursos do Azure são implantados e gerenciados. Crie um grupo de recursos do 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'"

Criar recursos de rede

Crie as configurações de sub-rede para myBackendSubnet e myAGSubnet usando New-AzVirtualNetworkSubnetConfig. Crie a rede virtual chamada myVNet usando New-AzVirtualNetwork com as configurações de sub-rede. Finalmente, crie o endereço IP público chamado myAGPublicIPAddress usando New-AzPublicIpAddress. Esses recursos fornecem conectividade de rede para o gateway de aplicativo e seus recursos associados.

Importante

A sub-rede do gateway de aplicativo (myAGSubnet) pode conter apenas gateways de aplicativo. Nenhum outro recurso é permitido nesta sub-rede. Crie as configurações de sub-rede para myBackendSubnet e myAGSubnet usando New-AzVirtualNetworkSubnetConfig. O Application Gateway requer uma sub-rede dedicada com um mínimo de /24 CIDR para operação adequada e dimensionamento futuro. Crie a rede virtual chamada myVNet usando New-AzVirtualNetwork com as configurações de sub-rede. Finalmente, crie o endereço IP público com SKU padrão e alocação estática para melhorar a segurança e o desempenho 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

Criar um gateway de aplicação

Nesta secção, cria recursos que suportam o gateway de aplicação, e, por fim, cria-o. Os recursos que criar incluem:

  • Configurações de IP e porta de front-end - associa a sub-rede que criou anteriormente ao gateway de aplicação e atribui uma porta a utilizar para aceder ao mesmo.
  • Pool predefinido - todos os gateways de aplicação precisam de ter, pelo menos, um conjunto de servidores backend.
  • Serviço de escuta e regra predefinidos - o serviço de escuta predefinido recebe tráfego na porta atribuída e a regra predefinida envia-o para o pool predefinido.

Criar as configurações de IP e a porta de front-end

Associe myAGSubnet que você criou anteriormente ao gateway de aplicativo usando New-AzApplicationGatewayIPConfiguration. Atribua myAGPublicIPAddress ao gateway de aplicativo usando New-AzApplicationGatewayFrontendIPConfig. Em seguida, crie a 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"

Criar o conjunto predefinido e as definições

Crie o pool de back-end padrão chamado appGatewayBackendPool para o gateway de aplicativo usando New-AzApplicationGatewayBackendAddressPool. Configure as definições para o pool de backend 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

Criar o ouvinte padrão e a regra predefinida

Um receptor é necessário para permitir que o gateway de aplicações roteie corretamente o tráfego para grupos de servidores back-end. Neste tutorial, você cria vários ouvintes para diferentes cenários de roteamento. O primeiro ouvinte básico espera tráfego na URL raiz. Os outros ouvintes esperam tráfego em caminhos de URL específicos, como http://203.0.113.1:8080/images/ ou http://203.0.113.1:8081/video/.

Crie um ouvinte chamado defaultListener usando New-AzApplicationGatewayHttpListener com a configuração de frontend e a porta de frontend que você criou anteriormente. É necessária uma regra para o ouvinte saber qual o pool de back-end a utilizar para o tráfego recebido. Crie uma regra básica chamada 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"

Criar o gateway de aplicação

Agora que você criou os recursos de suporte necessários, especifique parâmetros para o gateway de aplicativo chamado myAppGateway usando New-AzApplicationGatewaySku e, em seguida, crie-o 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

Adicionar pools de back-end e portas

Você pode adicionar pools de back-end ao seu gateway de aplicativo usando Add-AzApplicationGatewayBackendAddressPool. Neste exemplo, imagesBackendPool e videoBackendPool são criados para rotear tipos de conteúdo específicos. Você adiciona portas frontend para os pools usando Add-AzApplicationGatewayFrontendPort. Envie as alterações para o gateway de aplicativo 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

Adicionar ouvintes e regras

Adicionar ouvintes

Adicione os ouvintes chamados backendListener e redirectedListener que são necessários para rotear o tráfego 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

Adicionar o mapa de caminho de URL predefinido

Os mapas de caminho de URL garantem que URLs específicas são encaminhadas para pools de backend específicos. Você pode criar mapas de caminho de URL chamados 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

Adicionar configuração de redirecionamento

Você pode configurar o redirecionamento para o ouvinte 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"

Adicionar o mapa do caminho do URL de redirecionamento

Crie um mapa de caminho de URL separado para cenários de redirecionamento. Este mapa irá lidar com o tráfego na porta 8081 e redirecionar caminhos específicos para o ouvinte apropriado na 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"

Adicionar regras de encaminhamento

As regras de roteamento associam os mapas de URL aos ouvintes que você criou. Você pode adicionar as regras denominadas 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

Criar conjuntos de dimensionamento de máquinas virtuais

Neste exemplo, irá criar três grupos de dimensionamento de máquinas virtuais que suportam os três pools de back-end que criou. Os conjuntos de escala são denominados myvmss1, myvmss2 e myvmss3. Cada conjunto de dimensionamento contém duas instâncias de máquina virtual onde vai instalar o IIS. Pode atribuir a definição de escala ao pool de back-end quando configurar as definições de IP.

Importante

Substitua <username> e <password> por seus próprios valores antes de executar o script. Use uma senha forte que atenda aos requisitos de segurança do Azure. Nota de segurança: Substitua <username> e <password> por credenciais seguras. Considere usar o Azure Key Vault para gerenciamento de credenciais em cenários de produção.

# 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"

Instalar o IIS

O script a seguir instala o IIS nas máquinas virtuais em cada conjunto de escala e as configura para exibir conteúdo diferente com base em qual pool de back-end elas servem.

$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
}

Testar o portal de aplicações

Embora o IIS não seja necessário para criar o gateway de aplicativo, você o instalou neste tutorial para verificar se o Azure criou com êxito o gateway de aplicativo. Use o IIS para testar o gateway de aplicativo:

  1. Execute Get-AzPublicIPAddress para obter o endereço IP público do gateway de aplicativo:

    Get-AzPublicIPAddress -ResourceGroupName myResourceGroupAG -Name myAGPublicIPAddress

  2. Copie o endereço IP público e cole-o na barra de endereço do browser. Por exemplo:

    • http://203.0.113.1 (URL base)
    • http://203.0.113.1:8080/images/test.htm (caminho das imagens)
    • http://203.0.113.1:8080/video/test.htm (caminho do vídeo)
    • http://203.0.113.1:8081/images/test.htm (teste de redirecionamento)

Captura de tela mostrando a página de boas-vindas padrão do IIS ao testar a URL base do gateway de aplicativo.

Altere o URL para http://<ip-address>:8080/images/test.htm, substituindo o seu endereço IP por <ip-address>, e deverá ver algo como o seguinte exemplo:

Captura de tela mostrando a página de teste do pool de back-end de imagens ao acessar o caminho /images no gateway do aplicativo.

Altere o URL para http://<ip-address>:8080/video/test.htm, substituindo o seu endereço IP por <ip-address>, e deverá ver algo como o seguinte exemplo:

Captura de ecrã mostrando a página de teste do pool de vídeo back-end ao aceder ao caminho /video no gateway da aplicação.

Agora, altere o URL para http://<ip-address>:8081/images/test.htm, substituindo seu endereço IP por <ip-address>, e você verá o tráfego redirecionado de volta para o pool de back-end de imagens em http://<ip-address>:8080/images.

Monitorização do desempenho

Monitore as principais métricas do Application Gateway para obter o desempenho ideal:

  • Contagem de pedidos: Número total de pedidos processados
  • Tempo de resposta: Tempo médio de resposta para solicitações
  • Contagem de hosts não saudáveis: número de servidores backend não saudáveis
  • Rendimento: Taxa de transferência de dados através do Application Gateway

Limpeza de recursos

Quando não for mais necessário, remova o grupo de recursos, o gateway de aplicativo e todos os recursos relacionados usando Remove-AzResourceGroup.

Remove-AzResourceGroup -Name myResourceGroupAG

Próximos passos

Agora que você aprendeu o redirecionamento baseado em caminho de URL com o Application Gateway, explore estes cenários avançados:

Saiba mais sobre os recursos e capacidades do Application Gateway

Configurar a terminação de SSL com o Gateway de Aplicação

Implementar políticas do Web Application Firewall (WAF)

Configurar o Gateway de Aplicativo com Instâncias de Contêiner do Azure

Mais recursos

  • Last updated on