Freigeben über

Erstellen eines Anwendungsgateways mit Umleitung auf URL-Pfadbasis mithilfe von Azure PowerShell

Sie können mit Azure PowerShell Routingregeln auf URL-Pfadbasis konfigurieren, wenn Sie ein Anwendungsgateway erstellen. In diesem Tutorial erstellen Sie Back-End-Pools mithilfe von VM-Skalierungsgruppen. Anschließend erstellen Sie URL-Routingregeln, die den Webdatenverkehr basierend auf dem Anforderungs-URL-Pfad an den entsprechenden Back-End-Pool umleiten. Sie können Azure PowerShell verwenden, um erweiterte URL-basierte Routingregeln zu konfigurieren, wenn Sie ein Anwendungsgateway erstellen.

In diesem Lernprogramm werden produktionsfähige Konfigurationen behandelt, einschließlich bewährter Sicherheitsmethoden, Leistungsoptimierung und Überwachungseinrichtung.

In diesem Tutorial lernen Sie Folgendes:

  • Einrichten der Netzwerkinfrastruktur
  • Erstellen eines Anwendungsgateways mit pfadbasiertem Routing
  • Hinzufügen von Listenern und Routingregeln für die URL-Umleitung
  • Erstellen von VM-Skalierungsgruppen für Back-End-Pools
  • Testen der Routing- und Umleitungsfunktionen des Anwendungsgateways

Das folgende Beispiel zeigt Websitedatenverkehr, der von den Ports 8080 und 8081 gesendet und an die gleichen Back-End-Pools geleitet wird:

Diagramm der URL-Routing- und Umleitungsarchitektur.

Voraussetzungen

Sie können für dieses Verfahren auch die Azure-Befehlszeilenschnittstelle verwenden, wenn Ihnen dies lieber ist.

Bevor Sie mit diesem Lernprogramm beginnen, stellen Sie folgendes sicher:

  • Ein aktives Azure-Abonnement. Erstellen Sie ein kostenloses Konto, falls Sie noch keines haben.
  • Azure PowerShell-Modul Version 5.4.1 oder höher lokal installiert oder Zugriff auf Azure Cloud Shell
  • Berechtigungen des Typs „Mitwirkende“ oder „Besitzer“ für das Azure-Zielabonnement
  • Grundlegende Kenntnisse der Konzepte eines Application Gateways und des PowerShell-Skriptings

Hinweis

Es wird empfohlen, das Azure Az PowerShell-Modul für die Interaktion mit Azure zu verwenden. Informationen zu den ersten Schritten finden Sie unter Installieren von Azure PowerShell. Informationen zum Migrieren zum Az PowerShell-Modul finden Sie unter Migrieren von Azure PowerShell von AzureRM zum Az-Modul.

Azure Cloud Shell

Azure hostet Azure Cloud Shell, eine interaktive Shell-Umgebung, die Sie über Ihren Browser nutzen können. Sie können entweder Bash oder PowerShell mit Cloud Shell verwenden, um mit Azure-Diensten zu arbeiten. Sie können die vorinstallierten Befehle von Cloud Shell verwenden, um den Code in diesem Artikel auszuführen, ohne etwas in Ihrer lokalen Umgebung installieren zu müssen.

Starten von Azure Cloud Shell:

Option Beispiel/Link
Wählen Sie rechts oben in einem Code- oder Befehlsblock die Option Ausprobieren aus. Durch die Auswahl von Ausprobieren wird der Code oder Befehl nicht automatisch in Cloud Shell kopiert. Screenshot: Beispiel von „Ausprobieren“ für Azure Cloud Shell
Rufen Sie https://shell.azure.com auf, oder klicken Sie auf die Schaltfläche Cloud Shell starten, um Cloud Shell im Browser zu öffnen. Schaltfläche zum Starten von Azure Cloud Shell.
Wählen Sie im Azure-Portal rechts oben auf der Menüleiste die Schaltfläche Cloud Shell aus. Screenshot: Schaltfläche „Cloud Shell“ im Azure-Portal

So verwenden Sie Azure Cloud Shell

  1. Starten Sie Cloud Shell.

  2. Wählen Sie die Schaltfläche Kopieren für einen Codeblock (oder Befehlsblock) aus, um den Code oder Befehl zu kopieren.

  3. Fügen Sie den Code oder Befehl mit STRG+UMSCHALT+V unter Windows und Linux oder CMD+UMSCHALT+V unter macOS in die Cloud Shell-Sitzung ein.

  4. Drücken Sie die EINGABETASTE, um den Code oder Befehl auszuführen.

Wenn Sie PowerShell lokal installieren und verwenden möchten, erfordert dieses Lernprogramm die Azure PowerShell-Modulversion 5.4.1 oder höher. Führen Sie Get-Module -ListAvailable Az aus, um die Version zu finden. Wenn Sie ein Upgrade ausführen müssen, finden Sie unter Installieren des Azure PowerShell-Moduls Informationen dazu. Wenn Sie PowerShell lokal ausführen, müssen Sie auch Connect-AzAccount ausführen, um eine Verbindung mit Azure herzustellen.

Erstellen einer Ressourcengruppe

Eine Ressourcengruppe ist ein logischer Container, in dem Azure-Ressourcen bereitgestellt und verwaltet werden. Erstellen Sie mit New-AzResourceGroup eine Azure-Ressourcengruppe.

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

Erstellen von Netzwerkressourcen

Erstellen Sie mit New-AzVirtualNetworkSubnetConfig die Subnetzkonfigurationen für myBackendSubnet und myAGSubnet. Erstellen Sie mit New-AzVirtualNetwork und den Subnetzkonfigurationen das virtuelle Netzwerk myVNet. Erstellen Sie schließlich die öffentliche IP-Adresse " myAGPublicIPAddress " mit "New-AzPublicIpAddress". Diese Ressourcen stellen die Netzwerkkonnektivität mit dem Anwendungsgateway und den zugehörigen Ressourcen bereit.

Von Bedeutung

Das Anwendungsgateway-Subnetz (myAGSubnet) kann nur Anwendungsgateways enthalten. In diesem Subnetz sind keine anderen Ressourcen zulässig. Erstellen Sie mit New-AzVirtualNetworkSubnetConfig die Subnetzkonfigurationen für myBackendSubnet und myAGSubnet. Die Application Gateway-Instanz erfordert ein dediziertes Subnetz mit mindestens /24 CIDR für den ordnungsgemäßen Betrieb und die zukünftige Skalierung. Erstellen Sie mit New-AzVirtualNetwork und den Subnetzkonfigurationen das virtuelle Netzwerk myVNet. Erstellen Sie schließlich die öffentliche IP-Adresse mit Standard-SKU und statischer Zuweisung für verbesserte Sicherheit und Leistung mithilfe von 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

Erstellen eines Anwendungsgateways

In diesem Abschnitt erstellen Sie Ressourcen, die das Anwendungsgateway unterstützen, und schließlich das Anwendungsgateway selbst. Die Ressourcen, die Sie erstellen, umfassen:

  • IP-Konfigurationen und Front-End-Port: Ordnet das Subnetz, das Sie zuvor erstellt haben, dem Anwendungsgateway zu und weist einen Port für den Zugriff darauf zu.
  • Standardpool: Alle Anwendungsgateways müssen mindestens einen Back-End-Pool mit Servern haben.
  • Standardlistener und Regel: Der Standardlistener lauscht auf dem Port, der zugewiesen wurde, auf Datenverkehr, und die Standardregel sendet Datenverkehr an den Standardpool.

Erstellen der IP-Konfigurationen und des Front-End-Ports

Ordnen Sie das zuvor erstellte Subnetz myAGSubnet mithilfe von New-AzApplicationGatewayIPConfiguration dem Anwendungsgateway zu. Weisen Sie myAGPublicIPAddress mithilfe von New-AzApplicationGatewayFrontendIPConfig dem Anwendungsgateway zu. Erstellen Sie dann den HTTP-Port mit 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"

Erstellen des Standardpools und der Einstellungen

Erstellen Sie mit New-AzApplicationGatewayBackendAddressPool den Standard-Back-End-Pool appGatewayBackendPool für das Anwendungsgateway. Konfigurieren Sie mit New-AzApplicationGatewayBackendHttpSettings die Einstellungen für den Back-End-Pool.

# 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

Erstellen des Standardlisteners und einer Regel

Ein Listener ist erforderlich, damit das Anwendungsgateway den Datenverkehr entsprechend an Back-End-Pools weiterleiten kann. In diesem Lernprogramm erstellen Sie mehrere Listener für verschiedene Routingszenarien. Der erste grundlegende Listener erwartet Datenverkehr an der Stamm-URL. Die anderen Listener erwarten Datenverkehr an bestimmten URL-Pfaden, z. B. http://203.0.113.1:8080/images/ oder http://203.0.113.1:8081/video/.

Erstellen Sie einen Listener namens defaultListener mit New-AzApplicationGatewayHttpListener, der zuvor erstellten Front-End-Konfiguration und dem zuvor erstellten Front-End-Port. Für den Listener ist eine Regel erforderlich, damit bekannt ist, welcher Back-End-Pool für eingehenden Datenverkehr verwendet werden soll. Erstellen Sie mit New-AzApplicationGatewayRequestRoutingRule eine grundlegende Regel namens rule1.

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

Erstellen des Anwendungsgateways

Sie haben die erforderlichen unterstützenden Ressourcen erstellt. Geben Sie nun mit New-AzApplicationGatewaySku Parameter für das Anwendungsgateway myAppGateway an, und erstellen Sie es mit 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

Hinzufügen von Back-End-Pools und Ports

Sie können Ihrem Anwendungsgateway Back-End-Pools hinzufügen, indem Sie Add-AzApplicationGatewayBackendAddressPool verwenden. In diesem Beispiel werden imagesBackendPool und videoBackendPool für das Routing bestimmter Inhaltstypen erstellt. Sie fügen Front-End-Ports für die Pools mithilfe von Add-AzApplicationGatewayFrontendPort hinzu. Übermitteln Sie die Änderungen mit Set-AzApplicationGateway an das Anwendungsgateway.

# 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

Hinzufügen der Listener und Regeln

Hinzufügen der Listener

Fügen Sie mit Add-AzApplicationGatewayHttpListener die Listener namens backendListener und redirectedListener hinzu, die zum Weiterleiten des Datenverkehrs erforderlich sind.

# 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

Hinzufügen der standardmäßigen URL-Pfadzuordnung

URL-Pfadzuordnungen stellen sicher, dass bestimmte URLs an bestimmte Back-End-Pools weitergeleitet werden. Sie können URL-Pfadzuordnungen namens imagePathRule und videoPathRule mit New-AzApplicationGatewayPathRuleConfig und Add-AzApplicationGatewayUrlPathMapConfig erstellen.

# 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

Hinzufügen der Umleitungskonfiguration

Mit Add-AzApplicationGatewayRedirectConfiguration können Sie die Umleitung für den Listener konfigurieren.

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

Hinzufügen der URL-Pfadzuordnung für die Umleitung

Erstellen Sie eine separate URL-Pfadzuordnung für Umleitungsszenarien. Diese Zuordnung behandelt Datenverkehr an Port 8081 und leitet bestimmte Pfade an den entsprechenden Listener an Port 8080 um.

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

Hinzufügen von Routingregeln

Die Routingregeln ordnen die URL-Pfadzuordnungen den von Ihnen erstellten Listenern zu. Sie können mit dem Befehl Add-AzApplicationGatewayRequestRoutingRule die Regeln defaultRule und redirectedRule hinzufügen.

$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

Erstellen von VM-Skalierungsgruppen

In diesem Beispiel erstellen Sie drei VM-Skalierungsgruppen, die die drei von Ihnen erstellten Back-End-Pools unterstützen. Die Skalierungssätze heißen "myvmss1", "myvmss2" und "myvmss3". Jede Skalierungsgruppe enthält zwei VM-Instanzen, auf denen Sie IIS installieren. Sie weisen die Skalierungsgruppe dem Back-End-Pool zu, wenn Sie die IP-Einstellungen konfigurieren.

Von Bedeutung

Ersetzen Sie <username> durch Ihre eigenen Werte und <password> bevor Sie das Skript ausführen. Verwenden Sie ein sicheres Kennwort, das die Sicherheitsanforderungen von Azure erfüllt. Sicherheitshinweis: Ersetzen <username> und <password> durch sichere Anmeldeinformationen. Erwägen Sie die Verwendung von Azure Key Vault für die Verwaltung von Anmeldeinformationen in Produktionsszenarien.

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

Installieren von IIS

Das folgende Skript installiert IIS auf den virtuellen Computern in jedem Skalierungssatz und konfiguriert sie so, dass unterschiedliche Inhalte basierend auf dem von ihnen bereitgestellten Back-End-Pool angezeigt werden.

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

Testen des Anwendungsgateways

Obwohl IIS zum Erstellen des Anwendungsgateways nicht erforderlich ist, haben Sie es in diesem Lernprogramm installiert, um zu überprüfen, ob Azure das Anwendungsgateway erfolgreich erstellt hat. Testen des Anwendungsgateways mit IIS:

  1. Führen Sie Get-AzPublicIPAddress aus, um die öffentliche IP-Adresse des Anwendungsgateways abzurufen:

    Get-AzPublicIPAddress -ResourceGroupName myResourceGroupAG -Name myAGPublicIPAddress

  2. Kopieren Sie die öffentliche IP-Adresse, und fügen Sie sie in die Adressleiste des Browsers ein. Beispiel:

    • http://203.0.113.1 (Basis-URL)
    • http://203.0.113.1:8080/images/test.htm (Bildpfad)
    • http://203.0.113.1:8080/video/test.htm (Videopfad)
    • http://203.0.113.1:8081/images/test.htm (Umleitungstest)

Screenshot der standardmäßigen IIS-Willkommensseite beim Testen der Basis-URL des Anwendungsgateways.

Ändern Sie die URL in http://<ip-address>:8080/images/test.htm, ersetzen Sie Ihre IP-Adresse für <ip-address>, und Sie sollten etwas wie das folgende Beispiel sehen:

Screenshot der Testseite des Images-Back-End-Pools beim Zugriff auf den Pfad

Ändern Sie die URL in http://<ip-address>:8080/video/test.htm, ersetzen Sie Ihre IP-Adresse für <ip-address>, und Sie sollten etwas wie das folgende Beispiel sehen:

Screenshot der Testseite des Video-Back-End-Pools beim Zugriff auf den /video-Pfad auf dem Anwendungsgateway.

Ändern Sie nun die URL in http://<ip-address>:8081/images/test.htm, ersetzen Sie Ihre IP-Adresse durch <ip-address>, und Sie sollten den Datenverkehr zurück an den Images-Backend-Pool umgeleitet sehen. http://<ip-address>:8080/images

Leistungsüberwachung

Überwachen Sie die wichtigsten Metriken des Anwendungsgateways auf optimale Leistung:

  • Anforderungsanzahl: Gesamtanzahl der verarbeiteten Anforderungen
  • Antwortzeit: Durchschnittliche Antwortzeit für Anforderungen
  • Anzahl fehlerhafter Hosts: Anzahl fehlerhafter Back-End-Server
  • Durchsatz: Datenübertragungsrate über das Anwendungsgateway

Bereinigen von Ressourcen

Wenn Sie die Ressourcengruppe, das Anwendungsgateway und alle zugehörigen Ressourcen nicht mehr benötigen, entfernen Sie sie mit dem Befehl Remove-AzResourceGroup.

Remove-AzResourceGroup -Name myResourceGroupAG

Nächste Schritte

Nachdem Sie nun die pfadbasierte URL-Umleitung mit dem Anwendungsgateway gelernt haben, erkunden Sie die folgenden erweiterten Szenarien:

Weitere Informationen zu Features und Funktionen des Anwendungsgateways

Konfigurieren der SSL-Beendigung mit Application Gateway

Implementieren von RICHTLINIEN für die Webanwendungsfirewall (WAF)

Einrichten des Anwendungsgateways mit Azure-Containerinstanzen

Weitere Ressourcen

  • Last updated on