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-filmoduler

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. De filavsnitt som beskrivs nedan är de unika komponenterna för Virtual Network Manager. Utöver de avsnitt som beskrivs nedan distribuerar lösningen virtuella nätverk, en användartilldelad identitet och en rolltilldelning.

Virtual Network Manager, nätverksgrupper och anslutningskonfigurationer

Virtuell Nätverkschef

@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: []
    }
  }
}

Nätverksgrupper

Lösningen har stöd för att skapa antingen nätverksgrupper för statiskt medlemskap eller nätverksgrupper för dynamiskt medlemskap. Nätverksgruppen för statiskt medlemskap anger sina medlemmar efter virtuellt nätverks-ID

Nätverksgrupp för statiskt medlemskap

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

Nätverksgrupp för dynamiskt medlemskap

@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'
  }
}

Anslutningskonfiguration

Anslutningskonfigurationen associerar nätverksgruppen med den angivna nätverkstopologin.

@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'
  }
}

Distributionsskript

För att distribuera konfigurationen till målnätverksgruppen används ett distributionsskript för att anropa Deploy-AzNetworkManagerCommit PowerShell-kommandot. Distributionsskriptet behöver en identitet med tillräcklig behörighet för att köra PowerShell-skriptet mot Virtual Network Manager, så Bicep-filen skapar en användarhanterad identitet och ger den rollen Deltagare i målresursgruppen. Mer information om distributionsskript och associerade identiteter finns i Använda distributionsskript i ARM-mallar.

@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: $_"
    }
    '''
    }
}

Princip för dynamiskt nätverksgruppmedlemskap

När distributionen har konfigurerats för att använda dynamic nätverksgruppmedlemskap distribuerar lösningen även en Azure Policy-definition och tilldelning. Principdefinitionen visas nedan.

@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

Krav 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 (detta krävs när du använder distributionsparametern networkGroupMembershipType=Dynamic för att distribuera nödvändiga principresurser för nätverksgruppmedlemskap. Standardvärdet är static, som inte distribuerar en princip.

Ladda ned Bicep-lösningen

1. Ladda ned ett Zip-arkiv med MSPNP-lagringsplatsen på den här länken
2. Extrahera den nedladdade Zip-filen och gå till katalogen i terminalen solutions/avnm-mesh-connected-group/bicep .

Du kan också använda git för att klona lagringsplatsen med git clone https://github.com/mspnp/samples.git

Ansluta till Azure

Connect-AzAccount

Set-AzContext -Subscription <subscription name or id>

 Install-Module -Name Az.Network -RequiredVersion 5.3.0

az login

az account set -s <subscriptionId>

Distributionsparametrar

• resourceGroupName: [krävs] Den här parametern anger namnet på resursgruppen där den virtuella nätverkshanteraren och exempel på virtuella nätverk ska distribueras.
• location: [required] Den här parametern anger platsen för de resurser som ska distribueras.
• networkGroupMembershipType: [valfritt] Den här parametern anger vilken typ av nätverksgruppsmedlemskap som ska distribueras. Standardvärdet är static, men dynamiskt gruppmedlemskap kan användas genom att dynamicange .

    $templateParameterObject = @{
        'location' = '<resourceLocation>'
        'resourceGroupName' = '<newOrExistingResourceGroup>'
    }
    New-AzSubscriptionDeployment -TemplateFile ./main.bicep -Location <deploymentLocation> -TemplateParameterObject $templateParameterObject

    az deployment sub create -l <deploymentLocation> -f ./main.bicep -p location=<resourceLocation> resourceGroupName=<newOrExistingResourceGroup>

Verifiera konfigurationsdistribution

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

1. Gå till det virtuella nätverket vnet-learn-prod-{location}-spoke001 .

2. Under Inställningar väljer du Nätverkshanterare.

3. På fliken Anslutningskonfigurationer kontrollerar du att cc-learn-prod-{location}-mesh001 visas i listan.

   

4. 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 kan du ta bort det genom att ta bort resursgruppen och dess resurser.

1. I Azure Portal bläddrar du till resursgruppen – resursgrupp.
2. Välj resursgrupp och välj Ta bort resursgrupp.
3. I fönstret Ta bort en resursgrupp bekräftar du att du vill ta bort genom att ange resursgrupp i textrutan och välj sedan Ta bort.
4. Om du använde dynamiskt nätverksgruppmedlemskap tar du bort den distribuerade Azure Policy-definitionen och tilldelningen genom att navigera till prenumerationen i portalen och välja principer. I Principer letar du upp tilldelningen med namnet och tar bort den och gör sedan samma sak för definitionenAVNM quickstart dynamic group membership Policymed 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: