Distribuera och konfigurera Azure Firewall i ett hybridnätverk med hjälp av Azure PowerShell

När du ansluter ditt lokala nätverk till ett virtuellt Azure-nätverk för att skapa ett hybridnätverk är möjligheten att styra åtkomsten till dina Azure-nätverksresurser en viktig del av en övergripande säkerhetsplan.

Du kan använda Azure Firewall för att styra nätverksåtkomsten i ett hybridnätverk med hjälp av regler som definierar tillåten och nekad nätverkstrafik.

I den här artikeln skapar du tre virtuella nätverk:

VNet-Hub: Brandväggen finns i det här virtuella nätverket.
VNet-Spoke: Den virtuella spoke-nätverket representerar arbetsbelastning som ligger på Azure.
VNet-Onprem: Det lokala virtuella nätverket representerar ett lokalt nätverk. I en faktisk distribution kan du ansluta till den med hjälp av antingen en vpn-anslutning (virtuellt privat nätverk) eller en Azure ExpressRoute-anslutning. För enkelhetens skull använder den här artikeln en VPN-gatewayanslutning, och ett Azure-lokaliserat virtuellt nätverk representerar ett lokalt nätverk.

Om du i stället vill använda Azure-portalen för att slutföra procedurerna i den här artikeln kan du läsa Distribuera och konfigurera Azure Firewall i ett hybridnätverk med hjälp av Azure-portalen.

Note

Vi rekommenderar att du använder Azure Az PowerShell-modulen för att interagera med Azure. Se Installera Azure PowerShell för att komma igång. För att lära dig hur du migrerar till Az PowerShell-modulen, se Migrera Azure PowerShell från AzureRM till Az.

Prerequisites

Den här artikeln kräver att du kör PowerShell lokalt. Du måste ha Azure PowerShell-modulen installerad. Kör Get-Module -ListAvailable Az för att hitta versionen. Om du behöver uppgradera kan du läsa Installera Azure PowerShell-modulen. När du har verifierat PowerShell-versionen kör du Connect-AzAccount för att skapa en anslutning till Azure.

Tre viktiga krav säkerställer att det här scenariot fungerar korrekt:

En användardefinierad väg (UDR) i ekerundernätet pekar på Ip-adressen för Azure Firewall som standardgateway. Du måste inaktivera spridning av routning för virtuell nätverksgateway i den här routningstabellen.
En UDR på hubbgatewayens undernät pekar på brandväggens IP-adress som nästa hopp till spokenätverken.
Ingen UDR krävs i Azure Firewall-undernätet eftersom det lär sig vägar från Border Gateway Protocol (BGP).
Ange AllowGatewayTransit när du gör peering av VNet-Hub till VNet-Spoke. Ange UseRemoteGateways när du ansluter VNet-Spoke till VNet-Hub.

Avsnittet Skapa vägar senare i den här artikeln visar hur du skapar dessa vägar.

Note

Azure Firewall måste ha direkt Internetanslutning. Om ditt AzureFirewallSubnet-undernät lär sig en standardväg till ditt lokala nätverk via BGP måste du konfigurera Azure Firewall i läget för tvingad tunneltrafik. Om det här är en befintlig Azure Firewall-instans som inte kan konfigureras om i läget för tvingad tunneltrafik lägger du till en 0.0.0.0/0 UDR på AzureFirewallSubnet-undernätet med NextHopType värdet inställt Internet på att upprätthålla direkt internetanslutning.

Mer information finns i Framtvingad tunneltrafik i Azure Firewall.

Trafik mellan direktanslutna virtuella nätverk dirigeras direkt, även när en UDR pekar på Azure Firewall som standardgateway. Om du vill skicka trafik från undernät till undernät till brandväggen i det här scenariot måste en UDR innehålla målundernätsprefixet explicit i båda undernäten.

Använd New-AzFirewall som den primära cmdleten för att distribuera och konfigurera brandväggen i den här artikeln.

Om du inte har en Azure-prenumeration, skapa ett gratis konto innan du börjar.

Deklarera variablerna

I följande exempel deklareras variablerna med hjälp av värdena för den här artikeln. I vissa fall kan du behöva ersätta vissa värden med dina egna värden för att fungera i din prenumeration. Ändra variablerna om det behövs och kopiera och klistra in dem i PowerShell-konsolen.

$RG1 = "FW-Hybrid-Test"
$Location1 = "East US"

# Variables for the firewall hub virtual network

$VNetnameHub = "VNet-Hub"
$SNnameHub = "AzureFirewallSubnet"
$VNetHubPrefix = "10.5.0.0/16"
$SNHubPrefix = "10.5.0.0/24"
$SNGWHubPrefix = "10.5.1.0/24"
$GWHubName = "GW-hub"
$GWHubpipName = "VNet-Hub-GW-pip"
$GWIPconfNameHub = "GW-ipconf-hub"
$ConnectionNameHub = "hub-to-Onprem"

# Variables for the spoke virtual network

$VnetNameSpoke = "VNet-Spoke"
$SNnameSpoke = "SN-Workload"
$VNetSpokePrefix = "10.6.0.0/16"
$SNSpokePrefix = "10.6.0.0/24"
$SNSpokeGWPrefix = "10.6.1.0/24"

# Variables for the on-premises virtual network

$VNetnameOnprem = "Vnet-Onprem"
$SNNameOnprem = "SN-Corp"
$VNetOnpremPrefix = "192.168.0.0/16"
$SNOnpremPrefix = "192.168.1.0/24"
$SNGWOnpremPrefix = "192.168.2.0/24"
$GWOnpremName = "GW-Onprem"
$GWIPconfNameOnprem = "GW-ipconf-Onprem"
$ConnectionNameOnprem = "Onprem-to-hub"
$GWOnprempipName = "VNet-Onprem-GW-pip"

$SNnameGW = "GatewaySubnet"

Skapa de virtuella nätverken

Skapa det virtuella hubbnätverket

Använd New-AzResourceGroup för att skapa resursgruppen för den här artikeln:

New-AzResourceGroup `
    -Name $RG1 `
    -Location $Location1

Använd New-AzVirtualNetworkSubnetConfig och New-AzVirtualNetwork för att definiera undernäten och skapa det virtuella hubbnätverket:

$FWsub = New-AzVirtualNetworkSubnetConfig `
    -Name $SNnameHub `
    -AddressPrefix $SNHubPrefix

$GWsub = New-AzVirtualNetworkSubnetConfig `
    -Name $SNnameGW `
    -AddressPrefix $SNGWHubPrefix

$VNetHub = New-AzVirtualNetwork `
    -Name $VNetnameHub `
    -ResourceGroupName $RG1 `
    -Location $Location1 `
    -AddressPrefix $VNetHubPrefix `
    -Subnet $FWsub,$GWsub

Använd New-AzPublicIpAddress för att begära en offentlig IP-adress för VPN-gatewayen. Ange värdet AllocationMethod till Dynamic, vilket innebär att Azure dynamiskt allokerar adressen.

$gwpip1 = New-AzPublicIpAddress `
    -Name $GWHubpipName `
    -ResourceGroupName $RG1 `
    -Location $Location1 `
    -AllocationMethod Dynamic

Skapa det virtuella ekernätverket

Använd New-AzVirtualNetworkSubnetConfig och New-AzVirtualNetwork för att definiera undernäten och skapa det virtuella "spoke"-nätverket:

$Spokesub = New-AzVirtualNetworkSubnetConfig `
    -Name $SNnameSpoke `
    -AddressPrefix $SNSpokePrefix
$GWsubSpoke = New-AzVirtualNetworkSubnetConfig `
    -Name $SNnameGW `
    -AddressPrefix $SNSpokeGWPrefix
$VNetSpoke = New-AzVirtualNetwork `
    -Name $VnetNameSpoke `
    -ResourceGroupName $RG1 `
    -Location $Location1 `
    -AddressPrefix $VNetSpokePrefix `
    -Subnet $Spokesub,$GWsubSpoke

Skapa det lokala virtuella nätverket

Använd New-AzVirtualNetworkSubnetConfig och New-AzVirtualNetwork för att definiera undernäten och skapa det lokala virtuella nätverket:

$Onpremsub = New-AzVirtualNetworkSubnetConfig `
    -Name $SNNameOnprem `
    -AddressPrefix $SNOnpremPrefix
$GWOnpremsub = New-AzVirtualNetworkSubnetConfig `
    -Name $SNnameGW `
    -AddressPrefix $SNGWOnpremPrefix
$VNetOnprem = New-AzVirtualNetwork `
    -Name $VNetnameOnprem `
    -ResourceGroupName $RG1 `
    -Location $Location1 `
    -AddressPrefix $VNetOnpremPrefix `
    -Subnet $Onpremsub,$GWOnpremsub

Använd New-AzPublicIpAddress för att begära en offentlig IP-adress för den lokala virtuella nätverksgatewayen:

$gwOnprempip = New-AzPublicIpAddress `
    -Name $GWOnprempipName `
    -ResourceGroupName $RG1 `
    -Location $Location1 `
    -AllocationMethod Dynamic

Konfigurera och distribuera brandväggen

Använd New-AzPublicIpAddress och New-AzFirewall för att distribuera brandväggen till det virtuella hubbnätverket:

# Get a public IP for the firewall
$FWpip = New-AzPublicIpAddress `
    -Name "fw-pip" `
    -ResourceGroupName $RG1 `
    -Location $Location1 `
    -AllocationMethod Static `
    -Sku Standard
# Create the firewall
$Azfw = New-AzFirewall `
    -Name AzFW01 `
    -ResourceGroupName $RG1 `
    -Location $Location1 `
    -VirtualNetworkName $VNetnameHub `
    -PublicIpName fw-pip

# Save the firewall private IP address for future use
$AzfwPrivateIP = $Azfw.IpConfigurations.privateipaddress
$AzfwPrivateIP

Använd New-AzFirewallNetworkRule och New-AzFirewallNetworkRuleCollection för att konfigurera nätverksregler. Använd sedan Set-AzFirewall för att tillämpa dem:

$Rule1 = New-AzFirewallNetworkRule `
    -Name "AllowWeb" `
    -Protocol TCP `
    -SourceAddress $SNOnpremPrefix `
    -DestinationAddress $VNetSpokePrefix `
    -DestinationPort 80

$Rule2 = New-AzFirewallNetworkRule `
    -Name "AllowRDP" `
    -Protocol TCP `
    -SourceAddress $SNOnpremPrefix `
    -DestinationAddress $VNetSpokePrefix `
    -DestinationPort 3389

$Rule3 = New-AzFirewallNetworkRule `
    -Name "AllowPing" `
    -Protocol ICMP `
    -SourceAddress $SNOnpremPrefix `
    -DestinationAddress $VNetSpokePrefix `
    -DestinationPort *

$NetRuleCollection = New-AzFirewallNetworkRuleCollection `
    -Name RCNet01 `
    -Priority 100 `
    -Rule $Rule1,$Rule2,$Rule3 `
    -ActionType "Allow"
$Azfw.NetworkRuleCollections = $NetRuleCollection
Set-AzFirewall -AzureFirewall $Azfw

Skapa och ansluta VPN-gatewayerna

Du ansluter hubben och lokala virtuella nätverk via VPN-gatewayer.

Skapa en VPN-gateway för det virtuella hubbnätverket

Använd New-AzVirtualNetworkGatewayIpConfig för att skapa VPN-gatewaykonfigurationen för det virtuella hubbnätverket. Konfigurationen definierar undernätet och den offentliga IP-adress som ska användas.

$vnet1 = Get-AzVirtualNetwork `
    -Name $VNetnameHub `
    -ResourceGroupName $RG1
$subnet1 = Get-AzVirtualNetworkSubnetConfig `
    -Name "GatewaySubnet" `
    -VirtualNetwork $vnet1
$gwipconf1 = New-AzVirtualNetworkGatewayIpConfig `
    -Name $GWIPconfNameHub `
    -Subnet $subnet1 `
    -PublicIpAddress $gwpip1

Använd New-AzVirtualNetworkGateway för att skapa VPN-gatewayen för det virtuella hubbnätverket. Nätverk-till-nätverkskonfigurationer kräver värdet VpnTypeRouteBased. Det kan ofta ta 45 minuter eller mer att skapa en VPN-gateway, beroende på vilken SKU du väljer.

New-AzVirtualNetworkGateway `
    -Name $GWHubName `
    -ResourceGroupName $RG1 `
    -Location $Location1 `
    -IpConfigurations $gwipconf1 `
    -GatewayType Vpn `
    -VpnType RouteBased `
    -GatewaySku basic

Skapa en VPN-gateway för det lokala virtuella nätverket

Använd New-AzVirtualNetworkGatewayIpConfig för att skapa VPN-gatewaykonfigurationen för det lokala virtuella nätverket. Konfigurationen definierar undernätet och den offentliga IP-adress som ska användas.

$vnet2 = Get-AzVirtualNetwork `
    -Name $VNetnameOnprem `
    -ResourceGroupName $RG1
$subnet2 = Get-AzVirtualNetworkSubnetConfig `
    -Name "GatewaySubnet" `
    -VirtualNetwork $vnet2
$gwipconf2 = New-AzVirtualNetworkGatewayIpConfig `
    -Name $GWIPconfNameOnprem `
    -Subnet $subnet2 `
    -PublicIpAddress $gwOnprempip

Använd New-AzVirtualNetworkGateway för att skapa VPN-gatewayen för det lokala virtuella nätverket:

New-AzVirtualNetworkGateway `
    -Name $GWOnpremName `
    -ResourceGroupName $RG1 `
    -Location $Location1 `
    -IpConfigurations $gwipconf2 `
    -GatewayType Vpn `
    -VpnType RouteBased `
    -GatewaySku basic

Skapa VPN-anslutningarna

Skapa VPN-anslutningarna mellan hubben och lokala gatewayer.

Skapa anslutningarna

Använd Get-AzVirtualNetworkGateway för att hämta gatewayobjekten och använd sedan New-AzVirtualNetworkGatewayConnection för att skapa anslutningarna. Exemplen visar en delad nyckel, men du kan använda dina egna värden. Det är viktigt att den delade nyckeln matchar för båda anslutningarna. Det kan ta en kort stund att skapa en anslutning.

$vnetHubgw = Get-AzVirtualNetworkGateway `
    -Name $GWHubName `
    -ResourceGroupName $RG1
$vnetOnpremgw = Get-AzVirtualNetworkGateway `
    -Name $GWOnpremName `
    -ResourceGroupName $RG1
New-AzVirtualNetworkGatewayConnection `
    -Name $ConnectionNameHub `
    -ResourceGroupName $RG1 `
    -VirtualNetworkGateway1 $vnetHubgw `
    -VirtualNetworkGateway2 $vnetOnpremgw `
    -Location $Location1 `
    -ConnectionType Vnet2Vnet `
    -SharedKey 'AzureA1b2C3'

Skapa den virtuella nätverksanslutningen från lokal plats till hubben. Det här steget liknar det föregående, förutom att du skapar anslutningen från VNet-Onprem till VNet-Hub. Kontrollera att de delade nycklarna matchar. Anslutningen upprättas efter några minuter.

New-AzVirtualNetworkGatewayConnection `
    -Name $ConnectionNameOnprem `
    -ResourceGroupName $RG1 `
    -VirtualNetworkGateway1 $vnetOnpremgw `
    -VirtualNetworkGateway2 $vnetHubgw `
    -Location $Location1 `
    -ConnectionType Vnet2Vnet `
    -SharedKey 'AzureA1b2C3'

Verifiera anslutningen

Du kan verifiera en lyckad anslutning med hjälp av cmdleten Get-AzVirtualNetworkGatewayConnection , med eller utan -Debug.

Använd följande cmdlet-exempel, men konfigurera värdena så att de matchar dina egna. Om du uppmanas, välj A för att köra All. I exemplet -Name refererar till namnet på den anslutning som du vill testa.

Get-AzVirtualNetworkGatewayConnection `
    -Name $ConnectionNameHub `
    -ResourceGroupName $RG1

När cmdleten är klar visar du värdena. I följande exempel visas anslutningsstatusen Connected, tillsammans med inkommande och utgående byte:

"connectionStatus": "Connected",
"ingressBytesTransferred": 33509044,
"egressBytesTransferred": 4142431

Peer-koppla de virtuella hubb- och satellitnätverken

Använd Add-AzVirtualNetworkPeering för att ansluta de virtuella hubb- och spoke-nätverken:

# Peer hub to spoke
Add-AzVirtualNetworkPeering `
    -Name HubtoSpoke `
    -VirtualNetwork $VNetHub `
    -RemoteVirtualNetworkId $VNetSpoke.Id `
    -AllowGatewayTransit

# Peer spoke to hub
Add-AzVirtualNetworkPeering `
    -Name SpoketoHub `
    -VirtualNetwork $VNetSpoke `
    -RemoteVirtualNetworkId $VNetHub.Id `
    -AllowForwardedTraffic `
    -UseRemoteGateways

Skapa vägarna

Använd följande kommandon för att skapa dessa vägar:

En rutt från hubbgatewayens undernät till talundernätet via brandväggens IP-adress
En standardväg från spoke-subnätet genom brandväggens IP-adress

Använd New-AzRouteTable och Add-AzRouteConfig för att skapa routningstabellen och vägen för hubbgatewayundernätet. Använd sedan Set-AzVirtualNetworkSubnetConfig och Set-AzVirtualNetwork för att associera det med undernätet:

$routeTableHubSpoke = New-AzRouteTable `
    -Name 'UDR-Hub-Spoke' `
    -ResourceGroupName $RG1 `
    -Location $Location1

Get-AzRouteTable `
    -ResourceGroupName $RG1 `
    -Name UDR-Hub-Spoke `
    | Add-AzRouteConfig `
    -Name "ToSpoke" `
    -AddressPrefix $VNetSpokePrefix `
    -NextHopType "VirtualAppliance" `
    -NextHopIpAddress $AzfwPrivateIP `
    | Set-AzRouteTable

Set-AzVirtualNetworkSubnetConfig `
    -VirtualNetwork $VNetHub `
    -Name $SNnameGW `
    -AddressPrefix $SNGWHubPrefix `
    -RouteTable $routeTableHubSpoke `
    | Set-AzVirtualNetwork

Använd New-AzRouteTable och Add-AzRouteConfig för att skapa standardrutttabellen för ekerundernätet. Parametern -DisableBgpRoutePropagation inaktiverar spridning av routning för virtuell nätverksgateway i den här routningstabellen. Använd sedan Set-AzVirtualNetworkSubnetConfig och Set-AzVirtualNetwork för att associera det med undernätet:

$routeTableSpokeDG = New-AzRouteTable `
    -Name 'UDR-DG' `
    -ResourceGroupName $RG1 `
    -Location $Location1 `
    -DisableBgpRoutePropagation

Get-AzRouteTable `
    -ResourceGroupName $RG1 `
    -Name UDR-DG `
    | Add-AzRouteConfig `
    -Name "ToFirewall" `
    -AddressPrefix 0.0.0.0/0 `
    -NextHopType "VirtualAppliance" `
    -NextHopIpAddress $AzfwPrivateIP `
    | Set-AzRouteTable

Set-AzVirtualNetworkSubnetConfig `
    -VirtualNetwork $VNetSpoke `
    -Name $SNnameSpoke `
    -AddressPrefix $SNSpokePrefix `
    -RouteTable $routeTableSpokeDG `
    | Set-AzVirtualNetwork

Skapa virtuella datorer

Skapa spoke-arbetsbelastningen och de lokala virtuella datorerna, och placera dem i de lämpliga undernäten.

Skapa den virtuella arbetsbelastningsdatorn

Skapa en virtuell dator i spoke-virtuella nätverket som kör IIS (Internet Information Services), har ingen offentlig IP-adress och tillåter inkommande ping. När du uppmanas att ange ett användarnamn och lösenord för den virtuella datorn.

Använd New-AzNetworkSecurityRuleConfig och New-AzNetworkSecurityGroup för att skapa regler och säkerhetsgrupper för inkommande trafik:

# Create inbound network security group rules for ports 3389 and 80
$nsgRuleRDP = New-AzNetworkSecurityRuleConfig `
    -Name Allow-RDP `
    -Protocol Tcp `
    -Direction Inbound `
    -Priority 200 `
    -SourceAddressPrefix * `
    -SourcePortRange * `
    -DestinationAddressPrefix $SNSpokePrefix `
    -DestinationPortRange 3389 `
    -Access Allow
$nsgRuleWeb = New-AzNetworkSecurityRuleConfig `
    -Name Allow-web `
    -Protocol Tcp `
    -Direction Inbound `
    -Priority 202 `
    -SourceAddressPrefix * `
    -SourcePortRange * `
    -DestinationAddressPrefix $SNSpokePrefix `
    -DestinationPortRange 80 `
    -Access Allow

# Create the network security group
$nsg = New-AzNetworkSecurityGroup `
    -ResourceGroupName $RG1 `
    -Location $Location1 `
    -Name NSG-Spoke02 `
    -SecurityRules $nsgRuleRDP,$nsgRuleWeb

Använd New-AzNetworkInterface för att skapa nätverkskortet och koppla det till säkerhetsgruppen:

$NIC = New-AzNetworkInterface `
    -Name spoke-01 `
    -ResourceGroupName $RG1 `
    -Location $Location1 `
    -SubnetId $VnetSpoke.Subnets[0].Id `
    -NetworkSecurityGroupId $nsg.Id

Använd New-AzVMConfig, Set-AzVMOperatingSystem och Add-AzVMNetworkInterface för att definiera konfigurationen av den virtuella datorn och använd sedan New-AzVM för att skapa den virtuella datorn:

$VirtualMachine = New-AzVMConfig `
    -VMName VM-Spoke-01 `
    -VMSize "Standard_DS2"
$VirtualMachine = Set-AzVMOperatingSystem `
    -VM $VirtualMachine `
    -Windows `
    -ComputerName Spoke-01 `
    -ProvisionVMAgent `
    -EnableAutoUpdate
$VirtualMachine = Add-AzVMNetworkInterface `
    -VM $VirtualMachine `
    -Id $NIC.Id
$VirtualMachine = Set-AzVMSourceImage `
    -VM $VirtualMachine `
    -PublisherName 'MicrosoftWindowsServer' `
    -Offer 'WindowsServer' `
    -Skus '2016-Datacenter' `
    -Version latest

New-AzVM `
    -ResourceGroupName $RG1 `
    -Location $Location1 `
    -VM $VirtualMachine `
    -Verbose

Använd Set-AzVMExtension för att installera IIS och skapa en Windows-brandväggsregel för att tillåta ping:

# Install IIS
Set-AzVMExtension `
    -ResourceGroupName $RG1 `
    -ExtensionName IIS `
    -VMName VM-Spoke-01 `
    -Publisher Microsoft.Compute `
    -ExtensionType CustomScriptExtension `
    -TypeHandlerVersion 1.4 `
    -SettingString '{"commandToExecute":"powershell Add-WindowsFeature Web-Server"}' `
    -Location $Location1

# Create a Windows Firewall rule to allow pings
Set-AzVMExtension `
    -ResourceGroupName $RG1 `
    -ExtensionName AllowPing `
    -VMName VM-Spoke-01 `
    -Publisher Microsoft.Compute `
    -ExtensionType CustomScriptExtension `
    -TypeHandlerVersion 1.4 `
    -SettingString '{"commandToExecute":"powershell New-NetFirewallRule -DisplayName \"Allow ICMPv4-In\" -Protocol ICMPv4"}' `
    -Location $Location1

Skapa den lokala virtuella datorn

Använd New-AzVm för att skapa en enkel virtuell dator som du kan använda för att ansluta via fjärråtkomst till den offentliga IP-adressen. Därifrån kan du ansluta till den lokala servern via brandväggen. När du uppmanas till det anger du ett användarnamn och lösenord för den virtuella datorn.

New-AzVm `
    -ResourceGroupName $RG1 `
    -Name "VM-Onprem" `
    -Location $Location1 `
    -VirtualNetworkName $VNetnameOnprem `
    -SubnetName $SNNameOnprem `
    -OpenPorts 3389 `
    -Size "Standard_DS2"

Note

Azure tillhandahåller en standard-IP för utgående åtkomst för virtuella datorer som antingen inte har tilldelats någon offentlig IP-adress eller som finns i serverdelspoolen för en intern grundläggande Azure-lastbalanserare. Standardmekanismen för utgående IP-åtkomst tillhandahåller en utgående IP-adress som inte kan konfigureras.

Standard-IP för utgående åtkomst inaktiveras när någon av följande händelser inträffar:

En offentlig IP-adress tilldelas till den virtuella datorn.
Den virtuella datorn placeras i serverdelspoolen för en standardlastbalanserare, med eller utan regler för utgående trafik.
En Azure NAT Gateway-resurs tilldelas till den virtuella datorns undernät.

Virtuella datorer som du skapar med hjälp av virtuella maskinskalsatser i flexibelt orkestreringsläge saknar standardiserad utgående åtkomst.

Mer information om utgående anslutningar i Azure finns i Standardutgående åtkomst i Azure och Använda SNAT (Source Network Address Translation) för utgående anslutningar.

Testa brandväggen.

Hämta och notera den privata IP-adressen för den virtuella datorn VM-spoke-01 :
```
$NIC.IpConfigurations.privateipaddress
```
Från Azure-portalen ansluter du till den virtuella datorn VM-Onprem .
Öppna en Windows PowerShell-kommandotolk på VM-Onprem och pinga den privata IP-adressen för VM-spoke-01. Du får ett svar.
Öppna en webbläsare på VM-Onprem och bläddra till http://<VM-spoke-01 private IP>. Standardsidan för IIS bör öppnas.
Öppna en fjärråtkomstanslutning till VM-spoke-01 på den privata IP-adressen från VM-Onprem. Anslutningen bör lyckas och du bör kunna logga in med ditt valda användarnamn och lösenord.

När du har kontrollerat att brandväggsreglerna fungerar kan du:

Pinga servern i spoke-virtuella nätverket.
Navigera till webbservern på det virtuella spoke-nätverket.
Anslut till servern i spoke virtuellt nätverk via RDP.

Kör sedan följande skript för att ändra åtgärden för samlingen av brandväggsnätverksregler till Deny:

$rcNet = $Azfw.GetNetworkRuleCollectionByName("RCNet01")
$rcNet.action.type = "Deny"

Set-AzFirewall -AzureFirewall $Azfw

Stäng alla befintliga fjärråtkomstanslutningar. Kör testerna igen för att testa de ändrade reglerna. De ska alla misslyckas denna gång.

Rensa resurser

Du kan behålla brandväggsresurserna för nästa handledning. Om du inte längre behöver dem tar du bort resursgruppen FW-Hybrid-Test för att ta bort alla brandväggsrelaterade resurser.

Nästa steg

Övervaka Azure Firewall-loggar

Feedback

Var den här sidan till hjälp?

Last updated on 2026-03-31

Distribuera och konfigurera Azure Firewall i ett hybridnätverk med hjälp av Azure PowerShell

Prerequisites

Deklarera variablerna

Skapa de virtuella nätverken

Skapa det virtuella hubbnätverket

Skapa det virtuella ekernätverket

Skapa det lokala virtuella nätverket

Konfigurera och distribuera brandväggen

Skapa och ansluta VPN-gatewayerna

Skapa en VPN-gateway för det virtuella hubbnätverket

Skapa en VPN-gateway för det lokala virtuella nätverket

Skapa VPN-anslutningarna

Skapa anslutningarna

Verifiera anslutningen

Peer-koppla de virtuella hubb- och satellitnätverken

Skapa vägarna

Skapa virtuella datorer

Skapa den virtuella arbetsbelastningsdatorn

Skapa den lokala virtuella datorn

Testa brandväggen.

Rensa resurser

Nästa steg

Feedback

Ytterligare resurser