Início rápido: Criar uma máquina virtual do Azure Operator Nexus usando o Bicep

Implantar uma máquina virtual do Azure Nexus usando o Bicep

Este guia de início rápido foi projetado para ajudá-lo a começar a usar máquinas virtuais Nexus para hospedar VNFs (funções de rede virtual). Seguindo as etapas descritas neste guia, você pode criar com rapidez e facilidade uma máquina virtual Nexus personalizada que atenda às suas necessidades e requisitos específicos. Seja você iniciante ou especialista em rede Nexus, este guia está aqui para ajudar. Você aprende tudo o que precisa saber para criar e personalizar máquinas virtuais Nexus para hospedar funções de rede virtual.

Antes de começar

Se você ainda não tiver uma conta do Azure, crie uma conta gratuita antes de começar.

Utilize o ambiente Bash no Azure Cloud Shell. Para obter mais informações, confira Introdução ao Azure Cloud Shell.
Se você preferir executar comandos de referência da CLI localmente, instale a CLI do Azure. Se você estiver executando no Windows ou no macOS, considere executar a CLI do Azure em um contêiner do Docker. Para obter mais informações, confira Como executar a CLI do Azure em um contêiner do Docker.
- Se você estiver usando uma instalação local, entre na CLI do Azure usando o comando az login . Para concluir o processo de autenticação, siga as etapas exibidas em seu terminal. Para obter outras opções de entrada, consulte Autenticar no Azure usando a CLI do Azure.
- Quando solicitado, instale a extensão da CLI do Azure no primeiro uso. Para obter mais informações sobre extensões, confira Usar e gerenciar extensões com a CLI do Azure.
- Execute o comando az version para localizar a versão e as bibliotecas dependentes que estão instaladas. Para atualizar para a versão mais recente, execute az upgrade.

Instale a versão mais recente das extensões necessárias da CLI do Azure.
Se você tiver várias assinaturas do Azure, selecione a ID de assinatura apropriada na qual os recursos devem ser cobrados usando o az account comando.
Antes de prosseguir com a criação da máquina virtual, verifique se a imagem de contêiner a ser usada é criada de acordo com as instruções.
Crie um grupo de recursos usando o comando az group create. Um grupo de recursos do Azure é um grupo lógico no qual os recursos do Azure são implantados e gerenciados. Ao criar um grupo de recursos, você é solicitado a especificar um local. Essa é a localização na qual os metadados do grupo de recursos são armazenados e na qual os recursos são executados no Azure, caso você não especifique outra região durante a criação de recursos. O exemplo a seguir cria um grupo de recursos chamado myResourceGroup no local eastus .
```
az group create --name myResourceGroup --location eastus
```
O exemplo de saída a seguir se assemelha à criação bem-sucedida do grupo de recursos:
```
{
  "id": "/subscriptions/<guid>/resourceGroups/myResourceGroup",
  "location": "eastus",
  "managedBy": null,
  "name": "myResourceGroup",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null
}
```
Para implantar um arquivo Bicep ou um modelo do ARM, você precisa ter acesso de gravação nos recursos que está implantando e acesso a todas as operações no tipo de recurso Microsoft.Resources/deployments. Por exemplo, para implantar um cluster, você precisa de permissões Microsoft.NetworkCloud/virtualMachines/write e Microsoft.Resources/deployments/*. Para ver uma lista de funções e permissões, consulte Funções interna do Azure.
Você precisa da custom location ID de recurso do cluster Azure Operator Nexus.
Você precisa criar várias redes de acordo com seus requisitos específicos de carga de trabalho e é essencial ter os endereços IP apropriados disponíveis para suas cargas de trabalho. Para garantir uma implementação tranquila, é aconselhável consultar as equipes de suporte relevantes para obter assistência.

Conclua os pré-requisitos para implantar uma máquina virtual Nexus.

Examinar o modelo

Antes de implantar o modelo de máquina virtual, vamos examinar o conteúdo para entender sua estrutura.

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

Aviso

Os dados do usuário não são criptografados e qualquer processo na VM pode consultar esses dados. Você não deve armazenar informações confidenciais nos dados do usuário. Para obter mais informações, consulte as práticas recomendadas de segurança de dados e criptografia do Azure.

Examine e salve o arquivo de modelo nomeado virtual-machine-bicep-file.bicepe, em seguida, prossiga para a próxima seção e implante o modelo.

Máquinas virtuais com identidades gerenciadas

Crie a máquina virtual com uma identidade gerenciada atribuída pelo sistema ou atribuída pelo usuário. Para adicionar uma identidade gerenciada à VM, a versão da API deve ser 2025-07-01-preview ou posterior. Pode apiVersion ser populado com 2025-07-01-preview, 2025-09-01 ou qualquer versão futura da API.

Importante

Se você não especificar uma identidade gerenciada ao criar a VM, não poderá habilitar o suporte à identidade gerenciada atualizando a VM após o provisionamento.

Atualize a versão do recurso da máquina virtual no arquivo virtual-machine-bicep-file.bicep.

Adicione a seção identity com type definido como SystemAssigned no arquivo Bicep.

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

Para a identidade gerenciada atribuída pelo usuário, o recurso deve ser criado antes de ser atribuído à máquina virtual. Atualize o arquivo Bicep com a seção identity definida como type para UserAssigned, e inclua junto com a propriedade userAssignedIdentities a ID do recurso da identidade gerenciada atribuída pelo usuário.

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

Implantar o modelo

Crie um arquivo nomeado virtual-machine-parameters.json e adicione os parâmetros necessários no formato JSON. Você pode usar o exemplo a seguir como ponto de partida. Substitua os valores por seus próprios.

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

Implante o modelo.

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

Examinar os recursos implantados

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

Após a conclusão da implantação, você pode exibir os recursos usando a CLI ou o portal do Azure.

Para exibir os detalhes do myNexusVirtualMachine cluster no myResourceGroup grupo de recursos, execute o seguinte

Azure CLI

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

Limpar os recursos

Quando não for mais necessário, exclua o grupo de recursos. O grupo de recursos e todos os recursos do grupo de recursos são excluídos.

Azure CLI

Use o comando az group delete para remover o grupo de recursos, a máquina virtual e todos os recursos relacionados, exceto os recursos de rede do Operador Nexus.

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

Próximas etapas

A máquina virtual Nexus foi criada com êxito! Agora você pode usar a máquina virtual para hospedar VNFs (funções de rede virtual).

Comentários

Esta página foi útil?

Last updated on 2025-10-04