Share via

Guida introduttiva: Creare una macchina virtuale Nexus operatore di Azure con Bicep

  • Articolo
  • Distribuire una macchina virtuale Nexus di Azure con Bicep

Questa guida introduttiva è progettata per iniziare a usare le macchine virtuali Nexus per ospitare funzioni di rete virtuale (VNFS). Seguendo i passaggi descritti in questa guida, è possibile creare rapidamente e facilmente una macchina virtuale Nexus personalizzata che soddisfi esigenze e requisiti specifici. Che tu sia un principiante o un esperto di rete Nexus, questa guida è qui per aiutarti. Si apprenderà tutto ciò che è necessario sapere per creare e personalizzare le macchine virtuali Nexus per l'hosting di funzioni di rete virtuale.

Operazioni preliminari

Se non si ha una sottoscrizione di Azure, creare un account Azure gratuito prima di iniziare.

  • Installare la versione più recente delle estensioni dell'interfaccia della riga di comando di Azure necessarie.

  • Questo articolo richiede la versione 2.49.0 o successiva dell'interfaccia della riga di comando di Azure. Se si usa Azure Cloud Shell, la versione più recente è già installata.

  • Se sono presenti più sottoscrizioni di Azure, selezionare l'ID sottoscrizione appropriato in cui devono essere fatturate le risorse usando il az account comando .

  • Prima di procedere con la creazione della macchina virtuale, assicurarsi che l'immagine del contenitore da usare venga creata in base alle istruzioni.

  • Creare un gruppo di risorse usando il comando az group create. Un gruppo di risorse di Azure è un gruppo logico in cui le risorse di Azure vengono distribuite e gestite. Quando si crea un gruppo di risorse, viene richiesto di specificare una posizione. Questa posizione è la posizione di archiviazione dei metadati del gruppo di risorse e la posizione in cui le risorse vengono eseguite in Azure se non si specifica un'altra area durante la creazione delle risorse. L'esempio seguente crea un gruppo di risorse denominato myResourceGroup nella località stati uniti orientali.

    az group create --name myResourceGroup --location eastus

    L'esempio di output seguente è simile alla corretta creazione del gruppo di risorse:

    {
  "id": "/subscriptions/<guid>/resourceGroups/myResourceGroup",
  "location": "eastus",
  "managedBy": null,
  "name": "myResourceGroup",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null
}

  • Per distribuire un file Bicep o un modello di ARM, è necessario l'accesso in scrittura alle risorse distribuite e l'accesso per tutte le operazioni sul tipo di risorsa Microsoft.Resources/deployments. Ad esempio, per distribuire un cluster, sono necessarie le autorizzazioni Microsoft.NetworkCloud/virtualMachines/write e Microsoft.Resources/deployments/*. Per un elenco dei ruoli e delle autorizzazioni, vedere Ruoli predefiniti di Azure.

  • È necessario l'ID risorsa del cluster Nexus dell'operatore custom location di Azure.

  • È necessario creare diverse reti in base ai requisiti specifici del carico di lavoro ed è essenziale avere gli indirizzi IP appropriati disponibili per i carichi di lavoro. Per garantire un'implementazione uniforme, è consigliabile consultare i team di supporto pertinenti per assistenza.

  • Completare i prerequisiti per la distribuzione di una macchina virtuale Nexus.

Rivedere il modello

Prima di distribuire il modello di macchina virtuale, esaminare il contenuto per comprenderne la struttura.

@description('The name of Nexus virtual machine')
param vmName string

@description('The Azure region where the VM is to be deployed')
param location string = resourceGroup().location

@description('The custom location of the Nexus instance')
param extendedLocation string

@description('The metadata tags to be associated with the cluster resource')
param tags object = {}

@description('The name of the administrator to which the ssh public keys will be added into the authorized keys.')
@minLength(1)
@maxLength(32)
param adminUsername string = 'azureuser'

@description('Selects the boot method for the virtual machine.')
@allowed([
  'UEFI'
  'BIOS'
])
param bootMethod string = 'UEFI'

@description('The Cloud Services Network attachment ARM ID to attach to virtual machine.')
param cloudServicesNetworkId string

@description('Number of CPU cores for the virtual machine. Choose a value between 2 and 46.')
param cpuCores int = 2

@description('The memory size of the virtual machine in GB (max 224 GB)')
param memorySizeGB int = 4

@description('The list of network attachments to the virtual machine.')
param networkAttachments array

// {
//   attachedNetworkId: "string"
//   defaultGateway: "True"/"False"
//   ipAllocationMethod: "Dynamic"/"Static","Disabled"
//   ipv4Address: "string"
//   ipv6Address: "string"
//   networkAttachmentName: "string"
// }

@description('The Base64 encoded cloud-init network data.')
param networkData string = ''

@description('The placement hints for the virtual machine.')
param placementHints array = []
// {
//   hintType: "Affinity/AntiAffinity"
//   resourceId: string
//   schedulingExecution: "Hard/Soft"
//   scope: "Rack/Machine"
// }

@description('The list of SSH public keys for the virtual machine.')
param sshPublicKeys array
// {
//   keyData: 'string'
// }

@description('StorageProfile represents information about a disk.')
param storageProfile object = {
  osDisk: {
    createOption: 'Ephemeral'
    deleteOption: 'Delete'
    diskSizeGB: 64
  }
}

@description('The Base64 encoded cloud-init user data.')
param userData string = ''

@description('The type of the device model to use.')
@allowed([
  'T1'
  'T2'
])
param vmDeviceModel string = 'T2'

@description('The virtual machine image that is currently provisioned to the OS disk, using the full URL and tag notation used to pull the image.')
param vmImage string

@description('Credentials used to login to the image repository.')
param vmImageRepositoryCredentials object
// password: "string"
// registryUrl: "string"
// username: "string"

resource vm 'Microsoft.NetworkCloud/virtualMachines@2023-07-01' = {
  name: vmName
  location: location
  extendedLocation: {
    type: 'CustomLocation'
    name: extendedLocation
  }
  tags: tags
  properties: {
    adminUsername: (empty(adminUsername) ? null : adminUsername)
    bootMethod: (empty(bootMethod) ? null : bootMethod)
    cloudServicesNetworkAttachment: {
      attachedNetworkId: cloudServicesNetworkId
      defaultGateway: 'False'
      ipAllocationMethod: 'Dynamic'
    }
    cpuCores: cpuCores
    memorySizeGB: memorySizeGB
    networkData: (empty(networkData) ? null : networkData)
    networkAttachments: (empty(networkAttachments) ? null : networkAttachments)
    placementHints: (empty(placementHints) ? null : placementHints)
    sshPublicKeys: (empty(sshPublicKeys) ? null : sshPublicKeys)
    storageProfile: (empty(storageProfile) ? null : storageProfile)
    userData: (empty(userData) ? null : userData)
    vmDeviceModel: (empty(vmDeviceModel) ? null : vmDeviceModel)
    vmImage: (empty(vmImage) ? null : vmImage)
    vmImageRepositoryCredentials: (empty(vmImageRepositoryCredentials) ? null : vmImageRepositoryCredentials)
  }
}

Dopo aver esaminato e salvato il file modello denominato virtual-machine-bicep-template.bicep, passare alla sezione successiva per distribuire il modello.

Distribuire il modello

  1. Creare un file denominato virtual-machine-parameters.json e aggiungere i parametri obbligatori in formato JSON. È possibile usare l'esempio seguente come punto di partenza. Sostituire i valori con quelli personalizzati.
{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentParameters.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
      "vmName": {
        "value": "myNexusVirtualMachine"
      },
      "location": {
        "value": "eastus"
      },
      "extendedLocation": {
        "value": "/subscriptions/<subscription>/resourcegroups/<cluster-managed-resource-group>/providers/microsoft.extendedlocation/customlocations/<custom-location-name>"
      },
      "cloudServicesNetworkId": {
          "value": "/subscriptions/<subscription>/resourceGroups/<network-resource-group>/providers/Microsoft.NetworkCloud/cloudServicesNetworks/<csn-name>"
      },
      "networkAttachments": {
          "value": [
            {
                "attachedNetworkId": "/subscriptions/<subscription>/resourceGroups/<network-resource-group>/providers/Microsoft.NetworkCloud/l3Networks/<l3network-name>",
                "ipAllocationMethod": "Dynamic",
                "defaultGateway": "True",
                "networkAttachmentName": "mgmt0"
            }
        ]
      },
      "sshPublicKeys": {
          "value": [
            {
                "keyData": "ssh-rsa AAAAB3...."
            }
        ]
      },
      "vmImage": {
          "value": "<Image ACR URL>"
      },
      "vmImageRepositoryCredentials": {
          "value": {
              "password": "********************",
              "registryUrl": "<ACR registry URL>",
              "username": "<ACR user name>"
          }
      }
    }
  }
  1. Distribuire il modello.
    az deployment group create --resource-group myResourceGroup --template-file virtual-machine-bicep-template.bicep --parameters @virtual-machine-parameters.json

Esaminare le risorse distribuite

Al termine della distribuzione, è possibile visualizzare le risorse usando l'interfaccia della riga di comando o il portale di Azure.

Per visualizzare i dettagli del myNexusVirtualMachine cluster nel myResourceGroup gruppo di risorse, eseguire quanto segue

az networkcloud virtualmachine show --name myNexusVirtualMachine --resource-group myResourceGroup

Pulire le risorse

Quando non è più necessario, eliminare il gruppo di risorse. Il gruppo di risorse e tutte le risorse nel gruppo di risorse vengono eliminati.

Usare il comando az group delete per rimuovere il gruppo di risorse, la macchina virtuale e tutte le risorse correlate, ad eccezione delle risorse di rete Operator Nexus.

az group delete --name myResourceGroup --yes --no-wait

Passaggi successivi

È stata creata correttamente una macchina virtuale Nexus. È ora possibile usare la macchina virtuale per ospitare le funzioni di rete virtuale .