Créer une passerelle d’application avec une redirection basée sur un chemin d’accès d’URL à l’aide d’Azure PowerShell

Vous pouvez utiliser Azure PowerShell pour configurer des règles de routage basé sur une URL lors de la création d’une passerelle d’application. Ce didacticiel montre comment créer des pools principaux à l’aide de groupes de machines virtuelles identiques. Vous créez ensuite des règles de routage d’URL qui redirigent le trafic web vers le pool principal approprié en fonction du chemin d’URL de la demande. Vous pouvez utiliser Azure PowerShell pour configurer des règles de routage avancées basées sur des URL lorsque vous créez une passerelle d’application.

Ce didacticiel traite des configurations prêtes pour la production, notamment les meilleures pratiques de sécurité, l’optimisation des performances et la configuration de la supervision.

Dans ce tutoriel, vous allez apprendre à :

Configurer l’infrastructure réseau
Créer une passerelle d’application avec le routage basé sur le chemin
Ajouter des auditeurs et des règles de routage pour la redirection d’URL.
Créer des groupes de machines virtuelles identiques pour les pools principaux
Tester la fonctionnalité de routage et de redirection de passerelle d’application

L’exemple suivant montre le trafic du site en provenance des ports 8080 et 8081, et sa redirection vers les même pools principaux :

Conditions préalables

Si vous préférez, vous pouvez suivre cette procédure en utilisant Azure CLI.

Avant de commencer ce tutoriel, vérifiez que vous disposez des points suivants :

Un abonnement Azure actif. Créez un compte gratuit si vous n’en avez pas.
Module Azure PowerShell version 5.4.1 ou ultérieure installée localement, ou accès à Azure Cloud Shell
Autorisations contributeur ou propriétaire sur l’abonnement Azure cible
Compréhension de base des concepts d’Application Gateway et des scripts PowerShell

Remarque

Nous vous recommandons d’utiliser le module Azure Az PowerShell pour interagir avec Azure. Pour bien démarrer, consultez Installer Azure PowerShell. Pour savoir comment migrer vers le module Az PowerShell, consultez Migrer Azure PowerShell à partir d’AzureRM vers Az.

Azure Cloud Shell

Azure héberge Azure Cloud Shell, un environnement d’interpréteur de commandes interactif que vous pouvez utiliser dans votre navigateur. Vous pouvez utiliser Bash ou PowerShell avec Cloud Shell pour utiliser les services Azure. Vous pouvez utiliser les commandes préinstallées Cloud Shell pour exécuter le code de cet article sans avoir à installer quoi que ce soit dans votre environnement local.

Pour démarrer Azure Cloud Shell :

Choix	Exemple/Lien
Sélectionnez Essayer en haut à droite d’un bloc de code ou de commande. Cette action n’a pas pour effet de copier automatiquement le code ni la commande dans Cloud Shell.
Accédez à https://shell.azure.com ou sélectionnez le bouton Lancer Cloud Shell pour ouvrir Cloud Shell dans votre navigateur.
Sélectionnez le bouton Cloud Shell dans la barre de menus en haut à droite du portail Azure.

Pour utiliser Azure Cloud Shell, procédez comme suit :

Démarrez Cloud Shell.
Sélectionnez le bouton Copier sur un bloc de code (ou un bloc de commande) pour copier le code ou la commande.
Collez le code ou la commande dans la session Cloud Shell en sélectionnant Ctrl+Maj+V (sur Windows et Linux) ou Cmd+Maj+V (sur macOS).
Sélectionnez Entrée pour exécuter le code ou la commande.

Si vous choisissez d’installer et d’utiliser PowerShell localement, ce tutoriel nécessite le module Azure PowerShell version 5.4.1 ou ultérieure. Pour connaître la version, exécutez Get-Module -ListAvailable Az. Si vous devez effectuer une mise à niveau, consultez Installer le module Azure PowerShell. Si vous exécutez PowerShell en local, vous devez également exécuter Connect-AzAccount pour créer une connexion avec Azure.

Créer un groupe de ressources

Un groupe de ressources est un conteneur logique dans lequel les ressources Azure sont déployées et gérées. Créez un groupe de ressources Azure à l’aide de 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'"

Créer des ressources réseau

Créez les configurations de sous-réseau pour myBackendSubnet et myAGSubnet en utilisant la cmdlet New-AzVirtualNetworkSubnetConfig. Créez le réseau virtuel nommé myVNet à l’aide de New-AzVirtualNetwork avec les configurations de sous-réseau. Enfin, créez l’adresse IP publique nommée myAGPublicIPAddress à l’aide de New-AzPublicIpAddress. Ces ressources fournissent une connectivité réseau à la passerelle d’application et à ses ressources associées.

Important

Le sous-réseau de passerelle d’application (myAGSubnet) ne peut contenir que des passerelles d’application. Aucune autre ressource n’est autorisée dans ce sous-réseau. Créez les configurations de sous-réseau pour myBackendSubnet et myAGSubnet en utilisant la cmdlet New-AzVirtualNetworkSubnetConfig. Application Gateway nécessite un sous-réseau dédié avec un CIDR /24 minimum pour une opération appropriée et une mise à l’échelle ultérieure. Créez le réseau virtuel nommé myVNet à l’aide de New-AzVirtualNetwork avec les configurations de sous-réseau. Enfin, créez l’adresse IP publique avec la référence SKU Standard et l’allocation statique pour améliorer la sécurité et les performances à l’aide de 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

Créer une passerelle Application Gateway

Dans cette section, vous créez des ressources qui prennent en charge la passerelle d’application avant de créer cette dernière. Les ressources que vous créez sont les suivantes :

Configurations IP et port frontend : associe le sous-réseau que vous avez créé précédemment pour la passerelle d’application et assigne un port à utiliser pour y accéder.
Pool par défaut : toutes les passerelles d’application doivent avoir au moins un pool principal de serveurs.
Écouteur et règle par défaut : l’écouteur par défaut écoute le trafic sur le port assigné et la règle par défaut envoie le trafic au pool par défaut.

Créer les configurations IP et le port frontal

Associez myAGSubnet créé précédemment à la passerelle d’application à l’aide de New-AzApplicationGatewayIPConfiguration. Affectez myAGPublicIPAddress à la passerelle d’application à l’aide de New-AzApplicationGatewayFrontendIPConfig. Créez ensuite le port HTTP à l’aide de 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"

Créer le pool par défaut et les paramètres

Créez le pool back-end par défaut nommé appGatewayBackendPool pour la passerelle d’application à l’aide de New-AzApplicationGatewayBackendAddressPool. Configurez les paramètres pour le pool back-end à l’aide de 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

Créer l’écouteur et la règle par défaut

Un écouteur est nécessaire pour permettre à la passerelle Application Gateway d’acheminer le trafic de manière appropriée vers les pools principaux. Dans ce tutoriel, vous créez plusieurs écouteurs pour différents scénarios de routage. Le premier écouteur de base attend le trafic à l’URL racine. Les autres auditeurs attendent du trafic à des chemins d'URL spécifiques, tels que http://203.0.113.1:8080/images/ ou http://203.0.113.1:8081/video/.

Créez un écouteur nommé defaultListener à l’aide de New-AzApplicationGatewayHttpListener avec la configuration frontale et le port frontal que vous avez créés précédemment. Une règle est requise pour que l’écouteur sache quel pool principal utiliser pour le trafic entrant. Créez une règle de base nommée rule1 à l’aide de 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"

Créer la passerelle Application Gateway

Maintenant que vous avez créé les ressources nécessaires pour la prise en charge, spécifiez des paramètres de la passerelle d’application nommée myAppGateway à l’aide de New-AzApplicationGatewaySku, puis créez-la à l’aide de 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

Ajouter des ports et des pools principaux

Vous pouvez ajouter des pools principaux à votre passerelle d’application à l’aide de Add-AzApplicationGatewayBackendAddressPool. Dans cet exemple, imagesBackendPool et videoBackendPool sont créées pour le routage de types de contenu spécifiques. Vous ajoutez des ports frontend pour les pools à l’aide de Add-AzApplicationGatewayFrontendPort. Soumettez les changements à la passerelle d’application à l’aide de 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

Ajouter des écouteurs et des règles

Ajouter des écouteurs

Ajoutez les écouteurs nommés backendListener et redirectedListener, nécessaires pour router le trafic, en utilisant la cmdlet 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

Ajouter le mappage de chemin d’accès d’URL par défaut

Les cartes de chemin d’accès URL assurent que certaines URL sont acheminées vers des pools principaux spécifiques. Vous pouvez créer des mappages de chemins d’URL nommés imagePathRule et videoPathRule à l’aide de New-AzApplicationGatewayPathRuleConfig et 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

Ajouter une configuration de redirection

Vous pouvez configurer la redirection de l’écouteur en utilisant la cmdlet 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"

Ajouter le mappage de chemin d’accès d’URL de redirection

Créez un mappage de chemin d’URL distinct pour les scénarios de redirection. Cette carte gère le trafic sur le port 8081 et redirige les chemins spécifiques vers l’écouteur approprié sur le port 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"

Ajouter des règles de routage

Les règles d’acheminement associent les cartes d’URL aux écouteurs que vous avez créés. Vous pouvez ajouter les règles nommées defaultRule et redirectedRule en utilisant la cmdlet 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

Créer des groupes de machines virtuelles identiques

Cet exemple crée trois groupes de machines virtuelles identiques prenant en charge les trois pools principaux qui ont été créés. Les jeux d'échelles sont nommés myvmss1, myvmss2 et myvmss3. Chacun contient deux instances de machines virtuelles sur lesquelles IIS sera installé. Vous assignez le groupe identique au pool principal lorsque vous configurez les paramètres IP.

Important

Remplacez <username> et <password> par vos propres valeurs avant d’exécuter le script. Utilisez un mot de passe fort qui répond aux exigences de sécurité d’Azure. Remarque de sécurité : Remplacez <username> et <password> par des identifiants sécurisés. Envisagez d’utiliser Azure Key Vault pour la gestion des informations d’identification dans les scénarios de production.

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

Installer IIS

Le script suivant installe IIS sur les machines virtuelles de chaque ensemble à échelle et les configure pour afficher du contenu différent en fonction du pool principal qu’ils servent.

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

Tester la passerelle d’application

Bien que IIS n’ait pas besoin de créer la passerelle Application Gateway, vous l’avez installée dans ce tutoriel pour vérifier si Azure a correctement créé la passerelle d’application. Utilisez IIS pour tester la passerelle d’application :

Exécutez Get-AzPublicIPAddress pour obtenir l’adresse IP publique de la passerelle d’application :
```
Get-AzPublicIPAddress -ResourceGroupName myResourceGroupAG -Name myAGPublicIPAddress
```
Copiez l’adresse IP publique, puis collez-la dans la barre d’adresses de votre navigateur. Par exemple:
- http://203.0.113.1 (URL de base)
- http://203.0.113.1:8080/images/test.htm (chemin d’accès aux images)
- http://203.0.113.1:8080/video/test.htm (chemin d’accès vidéo)
- http://203.0.113.1:8081/images/test.htm (test de redirection)

Remplacez l’URL http://<ip-address>:8080/images/test.htmpar , en remplaçant votre adresse IP pour <ip-address>, et vous devez voir quelque chose comme dans l’exemple suivant :

Remplacez l’URL http://<ip-address>:8080/video/test.htmpar , en remplaçant votre adresse IP pour <ip-address>, et vous devez voir quelque chose comme dans l’exemple suivant :

À présent, remplacez l’URL http://<ip-address>:8081/images/test.htmpar , en remplaçant votre adresse IP pour <ip-address>, et vous devez voir le trafic redirigé vers le pool principal d’images à l’adresse http://<ip-address>:8080/images.

analyse des performances.

Surveillez les métriques Application Gateway clés pour obtenir des performances optimales :

Nombre de demandes : nombre total de demandes traitées
Temps de réponse : temps de réponse moyen pour les demandes
Nombre d’hôtes non sains : nombre de serveurs principaux défectueux
Débit : taux de transfert de données via Application Gateway

Nettoyer les ressources

Quand vous n’en avez plus besoin, supprimez le groupe de ressources, la passerelle d’application et toutes les ressources associées à l’aide de Remove-AzResourceGroup.

Remove-AzResourceGroup -Name myResourceGroupAG

Étapes suivantes

Maintenant que vous avez appris la redirection basée sur le chemin d’URL avec Application Gateway, explorez ces scénarios avancés :

En savoir plus sur les fonctionnalités et fonctionnalités d’Application Gateway

Configurer la terminaison SSL avec Application Gateway

Implémenter des stratégies waf (Web Application Firewall)

Configurer Application Gateway avec Azure Container Instances

Plus de ressources

Rétroaction

Cette page vous a-t-elle été utile ?

Last updated on 2025-07-23