Guía rápida: Crear una máquina virtual de Azure Operator Nexus mediante Bicep

• Implementación de una máquina virtual de Azure Nexus mediante Bicep

Esta guía de inicio rápido está diseñada para ayudarle a empezar a usar máquinas virtuales Nexus para hospedar funciones de red virtual (VNFs). Siguiendo los pasos descritos en esta guía, podrá crear rápidamente y fácilmente una máquina virtual Nexus personalizada que satisfaga sus necesidades y requisitos específicos. Tanto si es principiante como experto en redes Nexus, esta guía está aquí para ayudarle. Aprenderá todo lo que necesita saber para crear y personalizar máquinas virtuales Nexus para hospedar funciones de red virtual.

Antes de empezar

Si no tiene una cuenta de Azure, cree una cuenta gratuita antes de comenzar.

• Use el entorno de Bash en Azure Cloud Shell. Para más información, consulte Introducción a Azure Cloud Shell.

  

• Si prefieres ejecutar comandos de referencia CLI localmente, instala la CLI de Azure. Si estás utilizando Windows o macOS, considera ejecutar Azure CLI en un contenedor Docker. Para obtener más información, consulte Cómo ejecutar el Azure CLI en un contenedor de Docker.

  • Si estás utilizando una instalación local, inicia sesión en Azure CLI utilizando el comando az login. Siga los pasos que se muestran en el terminal para completar el proceso de autenticación. Para ver otras opciones de inicio de sesión, consulte Autenticación en Azure mediante la CLI de Azure.

  • En caso de que se le solicite, instale las extensiones de la CLI de Azure la primera vez que la use. Para obtener más información sobre las extensiones, consulte Uso y administración de extensiones con la CLI de Azure.

  • Ejecute az version para ver la versión y las bibliotecas dependientes que están instaladas. Para actualizar a la versión más reciente, ejecute az upgrade.

• Instale la versión más reciente de las extensiones de la CLI de Azure necesarias.

• Si tiene varias suscripciones de Azure, seleccione el identificador de suscripción adecuado en el que se deben facturar los recursos mediante el az account comando .

• Antes de continuar con la creación de la máquina virtual, asegúrese de que la imagen de contenedor que se va a usar se crea según las instrucciones.

• Cree un grupo de recursos con el comando az group create. Un grupo de recursos de Azure es un grupo lógico en el que se implementan y administran recursos de Azure. Cuando crea un grupo de recursos, se le pide que especifique una ubicación. Esta ubicación es la ubicación de almacenamiento de los metadatos del grupo de recursos y donde se ejecutan los recursos en Azure si no se especifica otra región durante la creación de recursos. En el ejemplo siguiente, se crea un grupo de recursos denominado myResourceGroup en la ubicación eastus.

  az group create --name myResourceGroup --location eastus
  

  El siguiente ejemplo de salida se asemeja a la creación exitosa del grupo de recursos.

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

• Para implementar un archivo de Bicep o una plantilla de ARM, necesitas acceso de escritura en los recursos que estás implementando y acceso para realizar todas las operaciones en el tipo de recurso Microsoft.Resources/deployments. Por ejemplo, para implementar un clúster, necesita permisos Microsoft.NetworkCloud/virtualMachines/write y Microsoft.Resources/deployments/*. Para obtener una lista de roles y permisos, consulte Roles integrados de Azure.

• Necesitas el ID de recurso del clúster de Azure Operator Nexus.

• Debe crear varias redes según los requisitos específicos de la carga de trabajo y es esencial tener las direcciones IP adecuadas disponibles para las cargas de trabajo. Para garantizar una implementación fluida, es aconsejable consultar a los equipos de soporte técnico pertinentes para obtener ayuda.

• Complete los requisitos previos para implementar una máquina virtual Nexus.

Revisión de la plantilla

Antes de implementar la plantilla de máquina virtual, vamos a revisar el contenido para comprender su estructura.

@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 GiB (max 224 GiB)')
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@2025-09-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
      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)
  }
}

Revise y guarde el archivo de plantilla denominado virtual-machine-bicep-file.bicepy, a continuación, continúe con la sección siguiente e implemente la plantilla.

Máquinas virtuales con identidades administradas

Cree la máquina virtual con una identidad administrada asignada por el sistema o asignada por el usuario. Para agregar una identidad administrada a la máquina virtual, la versión de la API debe ser 2025-07-01-preview o posterior. apiVersion se puede rellenar con 2025-07-01-preview, 2025-09-01 o cualquier versión futura de la API.

Asegúrese de actualizar la versión del recurso de la máquina virtual en el virtual-machine-bicep-file.bicep archivo.

Agregue la sección identity al archivo de Bicep con type establecido en SystemAssigned.

resource vm 'Microsoft.NetworkCloud/virtualMachines@2025-09-01' = {
  name: vmName
  ...
  properties: {
    ...
    identity: {
      type: "SystemAssigned"
    }
  }
}

En el caso de la identidad administrada asignada por el usuario, el recurso se debe crear para poder asignarlo a la máquina virtual. Actualice el archivo de Bicep en la sección identity, estableciendo type en UserAssigned, e incluya la propiedad userAssignedIdentities con el identificador de recurso de la identidad administrada asignada por el usuario.

resource vm 'Microsoft.NetworkCloud/virtualMachines@2025-09-01' = {
  name: vmName
  ...
  properties: {
    ...
    identity: {
      type: "UserAssigned",
      userAssignedIdentities: {
        "/subscriptions/{subscription-id}/resourceGroups/{resource-group-name}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identity-name}": {}
      }
    }
  }
}

Implementación de la plantilla

1. Cree un archivo denominado virtual-machine-parameters.json y agregue los parámetros necesarios en formato JSON. Puede usar el ejemplo siguiente como punto de partida. Reemplace los valores por los suyos propios.

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

2. Implemente la plantilla.

az deployment group create \
  --resource-group myResourceGroup
  --template-file virtual-machine-bicep-file.bicep
  --parameters @virtual-machine-parameters.json

Revisión de los recursos implementados

az deployment group show --resource-group myResourceGroup --name <deployment-name>

Una vez finalizada la implementación, puede ver los recursos mediante la CLI o Azure Portal.

Para ver los detalles del myNexusVirtualMachine clúster en el myResourceGroup grupo de recursos, ejecute lo siguiente:

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

Limpieza de recursos

Cuando ya no sea necesario, elimine el grupo de recursos. Se eliminan el grupo de recursos y todos los recursos del grupo de recursos.

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

Pasos siguientes

¡La máquina virtual Nexus se ha creado con éxito! Ahora puede usar la máquina virtual para hospedar funciones de red virtual (VNFs).