Compartilhar via

Guia de início rápido: criar uma máquina virtual Nexus do Operador do Azure usando o Bicep

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

Este guia de início rápido foi criado para ajudar você a começar a usar as máquinas virtuais Nexus para hospedar VNFs (funções de rede virtual). Ao seguir as etapas descritas neste guia, você poderá criar de forma rápida e fácil uma máquina virtual Nexus personalizada que atenda às suas necessidades e requisitos específicos. Seja você um iniciante ou um especialista em redes Nexus, este guia está aqui para ajudar. Você aprenderá tudo o que precisa saber para criar e personalizar máquinas virtuais Nexus para hospedar funções de rede virtual.

Antes de começar

Caso você não tenha uma assinatura do Azure, crie uma conta gratuita do Azure antes de começar.

  • Instale a última versão das extensões da CLI do Azure necessárias.

  • Este artigo requer a versão 2.49.0 ou posterior da CLI do Azure. Se você está usando o Azure Cloud Shell, a versão mais recente já está instalada.

  • Se tiver várias assinaturas do Azure, selecione a ID da assinatura adequada para cobrança dos recursos usando o comando az account.

  • Antes de prosseguir com a criação da máquina virtual, verifique se a imagem do contêiner a ser usada foi 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 é semelhante à 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 de acesso de gravação nos recursos que está implantando e acesso a todas as operações no tipo de recurso Microsoft.Resources/implantações. Por exemplo, para implantar um cluster, você precisa das 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 ID do recurso custom location do cluster do Nexus do Operador do Azure.

  • Você precisa criar várias redes de acordo com os requisitos específicos de sua carga de trabalho, e é essencial ter os endereços IP apropriados disponíveis para suas cargas de trabalho. Para garantir uma implementação tranquila, recomenda-se consultar as equipes de suporte relevantes para obter assistência.

  • Conclua os pré-requisitos para a implantação de uma máquina virtual Nexus.

Examinar o modelo

Antes de implantar o modelo de máquina virtual, vamos revisar 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@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)
  }
}

Depois de revisar e salvar o arquivo de modelo chamado virtual-machine-bicep-template.bicep, vá para a próxima seção para implantar o modelo.

Implantar o modelo

  1. Crie um arquivo chamado 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 pelos 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>"
          }
      }
    }
  }
  1. Implante o modelo.
    az deployment group create --resource-group myResourceGroup --template-file virtual-machine-bicep-template.bicep --parameters @virtual-machine-parameters.json

Examinar os recursos implantados

Depois que a implantação for concluída, você poderá exibir os recursos usando a CLI ou o portal do Azure.

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

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 no grupo de recursos são excluídos.

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 Operator Nexus.

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

Próximas etapas

Você criou com êxito uma máquina virtual Nexus. Agora você pode usar a máquina virtual para hospedar VNFs (funções de rede virtual).