Snabbstart: Skapa en nätnätverkstopologi med Azure Virtual Network Manager med hjälp av Bicep

Kom igång med Azure Virtual Network Manager med hjälp av Bicep för att hantera anslutningen för alla dina virtuella nätverk.

I den här snabbstarten distribuerar du tre virtuella nätverk och använder Azure Virtual Network Manager för att skapa en nätnätverkstopologi. Sedan kontrollerar du att anslutningskonfigurationen har tillämpats.

Bicep-lösningen för det här exemplet är uppdelad i moduler för att aktivera distributioner i både en resursgrupp och prenumerationsomfång. Följande avsnitt beskriver de komponenter som är unika för Azure Virtual Network Manager. Utöver dessa komponenter distribuerar lösningen virtuella nätverk, en användartilldelad identitet och en rolltilldelning.

Definiera resursen virtuell nätverkshanterare

Denna resurs skapar instansen Microsoft.Network/networkManagers , vid API-versionen 2022-09-01, som implementerar den anslutna gruppen för inter-virtuell nätverksanslutning. Ange networkManagerScopes för de prenumerationer eller hanteringsgrupper som instansen hanterar, och behåll Connectivity i networkManagerScopeAccesses så att instansen kan distribuera konfigurationer för anslutning.

@description('This is the Azure Virtual Network Manager which will be used to implement the connected group for inter-vnet connectivity.')
resource networkManager 'Microsoft.Network/networkManagers@2022-09-01' = {
  name: 'vnm-learn-prod-${location}-001'
  location: location
  properties: {
    networkManagerScopeAccesses: [
      'Connectivity'
    ]
    networkManagerScopes: {
      subscriptions: [
        '/subscriptions/${subscription().subscriptionId}'
      ]
      managementGroups: []
    }
  }
}

Definiera statiska och dynamiska nätverksgrupper

Lösningen stöder antingen en statisk medlemsnätverksgrupp eller en dynamisk medlemsnätverksgrupp. Parametern networkGroupMembershipType väljer vilken som distribueras; endast en av de två resurserna skapas.

Statisk medlemsnätverksgrupp

Den statiska nätverksgruppresursen, Microsoft.Network/networkManagers/networkGroups vid API-versionen 2022-09-01, namnger sina medlemmar explicit. De kapslade resurserna staticMembers lägger till spoke-virtuella nätverk A, B och C samt hubbvirtuella nätverket med resurs-ID. Om du vill rikta dina egna virtuella nätverk ändrar du parametrarna spokeNetworkGroupMembers och hubVnetId.

@description('This is the static network group for the all VNETs.')
resource networkGroupSpokesStatic 'Microsoft.Network/networkManagers/networkGroups@2022-09-01' = if (networkGroupMembershipType == 'static') {
  name: 'ng-learn-prod-${location}-static001'
  parent: networkManager
  properties: {
    description: 'Network Group - Static'
  }

  // add spoke vnets A, B, and C to the static network group
  resource staticMemberSpoke 'staticMembers@2022-09-01' = [for spokeMember in spokeNetworkGroupMembers: if (contains(groupedVNETs,last(split(spokeMember,'/')))) {
    name: 'sm-${(last(split(spokeMember, '/')))}'
    properties: {
      resourceId: spokeMember
    }
  }]

  resource staticMemberHub 'staticMembers@2022-09-01' = {
    name: 'sm-${(toLower(last(split(hubVnetId, '/'))))}'
    properties: {
      resourceId: hubVnetId
    }
  }
}

Dynamisk medlemsnätverksgrupp

Den dynamiska nätverksgruppresursen deklarerar inga medlemmar. Medlemskap fylls av Azure Policy-definitionen som beskrivs i Definiera den dynamiska medlemskapspolicyn.

@description('This is the dynamic group for all VNETs.')
resource networkGroupSpokesDynamic 'Microsoft.Network/networkManagers/networkGroups@2022-09-01' = if (networkGroupMembershipType == 'dynamic') {
  name: 'ng-learn-prod-${location}-dynamic001'
  parent: networkManager
  properties: {
    description: 'Network Group - Dynamic'
  }
}

Definiera mesh-anslutningskonfigurationen

Anslutningskonfigurationsresursen, Microsoft.Network/networkManagers/connectivityConfigurations i API-version 2022-09-01, associerar nätverksgruppen med mesh-nätverkstopologin. Egenskapen appliesToGroups refererar till nätverksgruppen du distribuerade, och du sätter connectivityTopology till Mesh.

@description('This connectivity configuration defines the connectivity between VNETs using Direct Connection. The hub will be part of the mesh, but gateway routes from the hub will not propagate to spokes.')
resource connectivityConfigurationMesh 'Microsoft.Network/networkManagers/connectivityConfigurations@2022-09-01' = {
  name: 'cc-learn-prod-${location}-mesh001'
  parent: networkManager
  properties: {
    description: 'Mesh connectivity configuration'
    appliesToGroups: [
      {
        networkGroupId: (networkGroupMembershipType == 'static') ? networkGroupSpokesStatic.id : networkGroupSpokesDynamic.id
        isGlobal: 'False'
        useHubGateway: 'False'
        groupConnectivity: 'DirectlyConnected'
      }
    ]
    connectivityTopology: 'Mesh'
    deleteExistingPeering: 'True'
    hubs: []
    isGlobal: 'False'
  }
}

Checka in konfigurationen med ett driftsättningsskript

För att distribuera konfigurationen till målnätverkets grupp, använd ett distributionsskript som anropar PowerShell-kommandot Deploy-AzNetworkManagerCommit. Distributionsskriptet behöver en identitet med tillräckliga behörigheter för att köra PowerShell-skriptet mot den virtuella nätverkshanteraren. Filen Bicep skapar en användarhanterad identitet och ger den rollen Deltagare i målresursgruppen. För mer information om distributionsskript och tillhörande identiteter, se Använd distributionsskript i ARM-mallar.

Följande resurs är en Microsoft.Resources/deploymentScripts resurs i API-versionen 2020-10-01. Den kör ett inbyggt PowerShell-skript som loggar in med användarens tilldelade identitet och anropar Deploy-AzNetworkManagerCommit. Byt egenskaper azPowerShellVersion, retentionInterval, och timeout för din egen utplacering. Ändra värdena som skickas via arguments: nätverkshanterarens namn, målplatser, konfigurations-ID:n, prenumerations-ID:t, konfigurationstypen och resursgruppens namn.

@description('Create a Deployment Script resource to perform the commit/deployment of the Network Manager connectivity configuration.')
resource deploymentScript 'Microsoft.Resources/deploymentScripts@2020-10-01' = {
  name: deploymentScriptName
  location: location
  kind: 'AzurePowerShell'
  identity: {
    type: 'UserAssigned'
    userAssignedIdentities: {
      '${userAssignedIdentityId}': {}
    }
  }
  properties: {
    azPowerShellVersion: '8.3'
    retentionInterval: 'PT1H'
    timeout: 'PT1H'
    arguments: '-networkManagerName "${networkManagerName}" -targetLocations ${location} -configIds ${configurationId} -subscriptionId ${subscription().subscriptionId} -configType ${configType} -resourceGroupName ${resourceGroup().name}'
    scriptContent: '''
    param (
      # AVNM subscription id
      [parameter(mandatory=$true)][string]$subscriptionId,

      # AVNM resource name
      [parameter(mandatory=$true)][string]$networkManagerName,

      # string with comma-separated list of config ids to deploy. ids must be of the same config type
      [parameter(mandatory=$true)][string[]]$configIds,

      # string with comma-separated list of deployment target regions
      [parameter(mandatory=$true)][string[]]$targetLocations,

      # configuration type to deploy. must be either connectivity or securityadmin
      [parameter(mandatory=$true)][ValidateSet('Connectivity','SecurityAdmin')][string]$configType,

      # AVNM resource group name
      [parameter(mandatory=$true)][string]$resourceGroupName
    )
  
    $null = Login-AzAccount -Identity -Subscription $subscriptionId
  
    [System.Collections.Generic.List[string]]$configIdList = @()  
    $configIdList.addRange($configIds) 
    [System.Collections.Generic.List[string]]$targetLocationList = @() # target locations for deployment
    $targetLocationList.addRange($targetLocations)     
    
    $deployment = @{
        Name = $networkManagerName
        ResourceGroupName = $resourceGroupName
        ConfigurationId = $configIdList
        TargetLocation = $targetLocationList
        CommitType = $configType
    }
  
    try {
      Deploy-AzNetworkManagerCommit @deployment -ErrorAction Stop
    }
    catch {
      Write-Error "Deployment failed with error: $_"
      throw "Deployment failed with error: $_"
    }
    '''
    }
}

Definiera den dynamiska medlemskapspolicyn

När du konfigurerar distributionen för att använda dynamic nätverksgruppsmedlemskap, distribuerar lösningen också en Azure Policy-definition och tilldelning.

Följande resurs är en Microsoft.Authorization/policyDefinitions resurs i API-versionen 2021-06-01. Den använder Microsoft.Network.Data policyläget och effekten addToNetworkGroup , som lägger till matchande virtuella nätverk till nätverksgruppen identifierad av networkGroupId. Policyregeln matchar virtuella nätverk som bär taggen _avnm_quickstart_deployment och som finns i detta stickprovs resursgrupp. Ändra taggnamnet och resursgruppfiltret i villkoret like för att matcha din egen miljö.

@description('This is a Policy definition for dynamic group membership')
resource policyDefinition 'Microsoft.Authorization/policyDefinitions@2021-06-01' = {
  name: uniqueString(networkGroupId)
  properties: {
    description: 'AVNM quickstart dynamic group membership Policy'
    displayName: 'AVNM quickstart dynamic group membership Policy'
    mode: 'Microsoft.Network.Data'
    policyRule: {
      if: {
        allof: [
          {
            field: 'type'
            equals: 'Microsoft.Network/virtualNetworks'
          }
          {
            // virtual networks must have a tag where the key is '_avnm_quickstart_deployment'
            field: 'tags[_avnm_quickstart_deployment]'
            exists: true
          }
          {
            // virtual network ids must include this sample's resource group ID - limiting the chance that dynamic membership impacts other vnets in your subscriptions
            field: 'id'
            like: '${subscription().id}/resourcegroups/${resourceGroupName}/*'
          }
        ]
      }
      then: {
        // 'addToNetworkGroup' is a special effect used by AVNM network groups
        effect: 'addToNetworkGroup'
        details: {
          networkGroupId: networkGroupId
        }
      }
    }
  }
}

Distribuera Bicep-lösningen

Förutsättningar för distribution

Ett Azure-konto med en aktiv prenumeration. Skapa ett konto utan kostnad.
Behörigheter för att skapa en principdefinition och principtilldelning i målprenumerationsomfånget. Du behöver dessa behörigheter när du använder distributionsparametern networkGroupMembershipType=Dynamic för att distribuera de principresurser som krävs för nätverksgruppsmedlemskap. Standardvärdet är static, vilket inte distribuerar någon Policy.
Alla resurser i den här lösningen är tillgängliga på lagringsplatsen Azure Exempel GitHub. Du kan ladda ned Bicep-lösningen från repot eller klona repot till din lokala dator.

Ladda ned Bicep-lösningen

Ladda ned ett ZIP-arkiv med exempelrepo på den här länken.
Extrahera den nedladdade ZIP-filen. Gå till den extraherade avnm-mesh-connected-group katalogen i terminalen. Bicep-filerna för den här lösningen finns i bicepunderkatalogen.

Du kan också använda git för att klona lagringsplatsen:

git clone https://github.com/Azure-Samples/avnm-mesh-connected-group
cd avnm-mesh-connected-group

Börja konfigurationen genom att logga in på ditt Azure-konto:

Connect-AzAccount

Anslut sedan till din prenumeration:

Set-AzContext -Subscription <subscription name or id>

Installera Azure PowerShell-modulen

Installera den senaste Azure PowerShell-modulen för Az.Network med hjälp av det här kommandot:

 Install-Module -Name Az.Network -RequiredVersion 5.3.0

Börja konfigurationen genom att logga in på ditt Azure-konto:

az login

Anslut sedan till din prenumeration med prenumerations-ID:

az account set -s <subscriptionId>

Utrullningsparametrar

resourceGroupName: [krävs] Namnet på resursgruppen där du vill distribuera den virtuella nätverkshanteraren och exempel på virtuella nätverk.
location: [required] Platsen för de resurser som ska distribueras.
networkGroupMembershipType: [valfritt] Vilken typ av nätverksgruppsmedlemskap som ska distribueras. Standardvärdet är static, men du kan använda dynamic för dynamiskt gruppmedlemskap.

Kommentar

Om du väljer dynamiskt gruppmedlemskap distribueras en Azure Policy för att hantera medlemskap, vilket kräver fler behörigheter.

PowerShell
Azure CLI

Standarddistribution med statiskt nätverksgruppmedlemskap

New-AzSubscriptionDeployment -Name avnm-mesh-connected-group -Location <deploymentLocation> -TemplateFile ./bicep/main.bicep -resourceGroupName <newOrExistingResourceGroup>

Distribution med dynamiskt nätverksgruppmedlemskap

Om du vill använda Azure Policy för att dynamiskt hantera medlemskapet i nätverksgruppen inkluderar du distributionsparametern networkGroupMembershipType med värdet dynamic.

New-AzSubscriptionDeployment -Name avnm-mesh-connected-group -Location <deploymentLocation> -TemplateFile ./bicep/main.bicep -resourceGroupName <newOrExistingResourceGroup> -networkGroupMembershipType dynamic

Standarddistribution med statiskt nätverksgruppmedlemskap

az deployment sub create --template-file ./bicep/main.bicep -n avnm-mesh-connected-group -l <deploymentLocation> --parameters resourceGroupName=<newOrExistingResourceGroup>

Distribution med dynamiskt nätverksgruppmedlemskap

Om du vill använda Azure Policy för att dynamiskt hantera medlemskapet i nätverksgruppen inkluderar du distributionsparametern networkGroupMembershipType med värdet dynamic.

az deployment sub create --template-file ./bicep/main.bicep -n avnm-mesh-connected-group -l <deploymentLocation> --parameters resourceGroupName=<newOrExistingResourceGroup> networkGroupMembershipType=dynamic

Verifiera distribution av konfiguration

Använd avsnittet Nätverkshanteraren för varje virtuellt nätverk för att kontrollera att du har distribuerat konfigurationen:

Gå till det virtuella nätverket vnet-learn-prod-{location}-spoke001 .
Under Inställningar väljer du Nätverkshanterare.
På fliken Anslutningskonfigurationer kontrollerar du att cc-learn-prod-{location}-mesh001 visas i listan.
Upprepa föregående steg på vnet-learn-prod-{location}-spoke004--du bör se att vnet-learn-prod-{location}-spoke004 undantas från anslutningskonfigurationen.

Rensa resurser

Om du inte längre behöver Azure Virtual Network Manager och de associerade virtuella nätverken tar du bort dem genom att ta bort resursgruppen och dess resurser.

I Azure Portal bläddrar du till resursgruppen – resursgrupp.
Välj resursgrupp och välj Ta bort resursgrupp.
I Ta bort en resursgrupp bekräftar du att du vill ta bort genom att ange resursgrupp i textrutan och välj sedan Ta bort.
Om du använde Dynamic Network Group Membership tar du bort den distribuerade Azure Policy-definitionen och tilldelningen genom att gå till prenumerationen i portalen och välja Policyer. I Principer letar du upp tilldelningen med namnet AVNM quickstart dynamic group membership Policy och tar bort den och gör sedan samma sak för definitionen med namnet AVNM quickstart dynamic group membership Policy.

Nästa steg

Nu när du har skapat en Azure Virtual Network Manager-instans lär du dig hur du blockerar nätverkstrafik med hjälp av en säkerhetsadministratörskonfiguration:

Blockera nätverkstrafik med Azure Virtual Network Manager

Feedback

Var den här sidan till hjälp?

Last updated on 2026-07-30