Compartilhar via

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

É possível usar o Azure PowerShell para configurar as regras de roteamento baseado em URL quando você cria um gateway de aplicativo. Neste tutorial, você criará pools de back-end usando 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, você aprenderá como:

  • Configurar a infraestrutura de rede
  • Criar um gateway de aplicativo com regras de roteamento baseado em caminho
  • Adicionar ouvintes e regras de roteamento para redirecionamento de URL
  • Criar conjuntos de dimensionamento de máquinas virtuais para pools de back-end
  • Testar a funcionalidade de roteamento e redirecionamento do gateway de aplicativo

O exemplo a seguir mostra o tráfego do site proveniente de ambas as portas 8080 e 8081 e sendo direcionado para os mesmos pools 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, verifique se você tem:

  • Uma assinatura ativa do Azure. Crie uma conta gratuita se ainda não tiver a sua.
  • 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 assinatura de destino do Azure
  • Uma compreensão básica dos conceitos do Gateway de Aplicativo e do script do PowerShell

Observação

Recomendamos que você use o módulo Azure Az PowerShell para interagir com o Azure. Para começar, consulte Instalar o Microsoft Azure PowerShell. Para saber como migrar para o módulo Az PowerShell, veja Migrar o Microsoft Azure PowerShell do AzureRM para o Az.

Azure Cloud Shell

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

Para iniciar o Azure Cloud Shell:

Opção Exemplo/Link
Selecione Experimentar no canto superior direito de um bloco de código ou de comando. Selecionar Experimentar não copia automaticamente o código nem o comando para o Cloud Shell. Captura de tela mostrando um exemplo de Experimentar para o Azure Cloud Shell.
Acesse https://shell.azure.com ou selecione o botão Iniciar o Cloud Shell para abri-lo 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 o comando.

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

  4. Selecione Enter para executar o código ou o 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 saber qual é a versão, execute Get-Module -ListAvailable Az. Se você precisa atualizar, consulte Instalar o módulo do Azure PowerShell. Se você estiver executando o PowerShell localmente, também precisará executar o 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 da rede

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

Importante

A sub-rede do gateway de aplicação (myAGSubnet) pode conter apenas gateways de aplicação. Nenhum outro recurso é permitido nesta sub-rede. Crie as configurações de sub-rede para myBackendSubnet e myAGSubnet usando New-AzVirtualNetworkSubnetConfig. O Gateway de Aplicativo requer uma sub-rede dedicada com CIDR mínimo /24 para operação adequada e escala futura. Crie a rede virtual denominada myVNet usando New-AzVirtualNetwork com as configurações e sub-rede. Por fim, crie o endereço IP público com SKU Standard 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 Aplicativo

Nesta seção, você cria recursos que suportam o gateway de aplicativo e, finalmente, cria isso. Os recursos que você criar incluem:

  • Configurações de IP e a porta de front-end - Associa a sub-rede que você criou anteriormente para o gateway de aplicativo e atribui uma porta a ser usada para acessá-lo.
  • Padrão de pool - Todos os gateways de aplicativo devem ter pelo menos um pool de back-end de servidores.
  • Ouvinte e regra padrão - O ouvinte padrão ouve o tráfego na porta que foi atribuído e a regra padrão envia tráfego para o pool padrão.

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

Associe a myAGSubnet criada 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 pool padrão e as configurações

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

Criar o ouvinte e regra padrão

Um ouvinte é necessário para habilitar o gateway de aplicativo para rotear o tráfego adequadamente para pools de back-end. Neste tutorial, você criará vários ouvintes para diferentes cenários de roteamento. O primeiro ouvinte básico espera tráfego na URL da 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 front-end e a porta front-end criadas anteriormente. Uma regra é necessária para o ouvinte saber qual pool de back-end deve ser usado para tráfego de entrada. 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 aplicativo

Agora que você criou os recursos de suporte necessários, especifique os parâmetros para o gateway de aplicativo denominado 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 e portas de back-end

É possível adicionar pools de back-end ao gateway de aplicativo, usando Add-AzApplicationGatewayBackendAddressPool. Neste exemplo, imagesBackendPool e videoBackendPool são criados para roteamento de tipos de conteúdo específicos. Adicione portas de front-end 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 denominados 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 padrão

Os mapas de caminho de URL certificam que as URLs específicas sejam roteadas para pools de back-end 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 a configuração de redirecionamento

É possível 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 de caminho de URL de redirecionamento

Crie um mapa de caminho de URL separado para cenários de redirecionamento. Este mapa manipulará 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 redirecionamento

A regra de roteamento associa o mapa de URL ao ouvinte que você criou. É possível adicionar as regras nomeadas 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, você cria três conjuntos de dimensionamento de máquinas virtuais que oferecem suporte a três pools de back-end que você criou. Os conjuntos de dimensionamento são denominados myvmss1, myvmss2 e myvmss3. Cada conjunto de dimensionamento contém duas instâncias de máquina virtual no qual você instala o IIS. Você atribui o conjunto de dimensionamento para o pool de back-end quando define as configurações de IP.

Importante

Substitua <username> e <password> com seus próprios valores antes de executar o script. Use uma senha forte que atenda aos requisitos de segurança do Azure. Observação de segurança: substitua <username> e <password> use credenciais seguras. Considere usar o Azure Key Vault para o 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 dimensionamento e os configura para exibir conteúdo diferente com base em qual pool de back-end eles 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 gateway de aplicativo

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ços do seu navegador. Por exemplo:

    • http://203.0.113.1 (URL base)
    • http://203.0.113.1:8080/images/test.htm (caminho de imagens)
    • http://203.0.113.1:8080/video/test.htm (caminho do video)
    • 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 a URL para http://<ip-address>:8080/images/test.htm, substituindo seu endereço <ip-address>IP, e você verá algo semelhante ao exemplo a seguir:

Captura de tela mostrando a página de teste do pool de imagens no backend ao acessar o caminho /images no gateway de aplicações.

Altere a URL para http://<ip-address>:8080/video/test.htm, substituindo seu endereço <ip-address>IP, e você verá algo semelhante ao exemplo a seguir:

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

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

Monitoramento de desempenho

Monitore as principais métricas do Gateway de Aplicativo para obter um desempenho ideal:

  • Contagem de solicitações: número total de solicitações processadas
  • Tempo de resposta: tempo médio de resposta para solicitações
  • Contagem de hosts não íntegros: número de servidores de back-end não íntegros
  • Throughput: taxa de transferência de dados por meio do Gateway de Aplicativo

Limpar os recursos

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

Remove-AzResourceGroup -Name myResourceGroupAG

Próximas etapas

Agora que você aprendeu o redirecionamento baseado no caminho de URL com o Gateway de Aplicações, explore estes cenários avançados:

Saiba mais sobre recursos e funcionalidades do Gateway de Aplicativo

Configurar a terminação SSL no Gateway de Aplicativo

Implementar políticas de WAF (Firewall de Aplicativo Web)

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

Mais recursos

  • Last updated on