Udostępnij za pośrednictwem

Szybki start: tworzenie maszyny wirtualnej Platformy Azure Operator Nexus przy użyciu narzędzia Bicep

  • Artykuł
  • Wdrażanie maszyny wirtualnej platformy Azure Nexus przy użyciu Bicep

Ten przewodnik Szybki start ułatwia rozpoczęcie pracy z maszynami wirtualnymi Nexus w celu hostowania funkcji sieci wirtualnej (VNFs). Wykonując kroki opisane w tym przewodniku, możesz szybko i łatwo utworzyć niestandardową maszynę wirtualną Nexus spełniającą określone potrzeby i wymagania. Niezależnie od tego, czy jesteś początkującym, czy ekspertem w dziedzinie sieci Nexus, ten przewodnik jest tutaj, aby pomóc. Dowiesz się, co musisz wiedzieć, aby tworzyć i dostosowywać maszyny wirtualne Nexus do hostowania funkcji sieci wirtualnej.

Zanim rozpoczniesz

Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto platformy Azure.

  • Zainstaluj najnowszą wersję niezbędnych rozszerzeń interfejsu wiersza polecenia platformy Azure.

  • Ten artykuł wymaga wersji 2.61.0 lub nowszej interfejsu wiersza polecenia platformy Azure. W przypadku korzystania z usługi Azure Cloud Shell najnowsza wersja jest już zainstalowana.

  • Jeśli masz wiele subskrypcji platformy Azure, wybierz odpowiedni identyfikator subskrypcji, w którym zasoby mają być rozliczane przy użyciu az account polecenia .

  • Przed kontynuowaniem tworzenia maszyny wirtualnej upewnij się, że obraz kontenera do użycia jest tworzony zgodnie z instrukcjami.

  • Utwórz grupę zasobów przy użyciu az group create polecenia . Grupa zasobów platformy Azure to grupa logiczna, w której zasoby platformy Azure są wdrażane i zarządzane. Podczas tworzenia grupy zasobów zostanie wyświetlony monit o określenie lokalizacji. Ta lokalizacja to lokalizacja magazynu metadanych grupy zasobów i lokalizacja, w której zasoby są uruchamiane na platformie Azure, jeśli nie określisz innego regionu podczas tworzenia zasobów. W poniższym przykładzie tworzona jest grupa zasobów o nazwie myResourceGroup w lokalizacji eastus.

    az group create --name myResourceGroup --location eastus

    Poniższy przykład danych wyjściowych przypomina pomyślne utworzenie grupy zasobów:

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

  • Aby wdrożyć plik Bicep lub szablon usługi ARM, potrzebujesz dostępu do zapisu w zasobach wdrażanych i dostępu do wszystkich operacji w typie zasobu Microsoft.Resources/deployments. Na przykład do wdrożenia klastra potrzebne są uprawnienia Microsoft.NetworkCloud/virtualMachines/write i Microsoft.Resources/deployments/*. Aby uzyskać listę ról i uprawnień, zobacz Role wbudowane platformy Azure.

  • Potrzebny jest identyfikator zasobu klastra Nexus operatora platformy custom location Azure.

  • Musisz utworzyć różne sieci zgodnie z określonymi wymaganiami dotyczącymi obciążenia i niezbędne jest posiadanie odpowiednich adresów IP dostępnych dla obciążeń. Aby zapewnić bezproblemową implementację, zaleca się skonsultowanie się z odpowiednimi zespołami pomocy technicznej w celu uzyskania pomocy.

Przegląd szablonu

Przed wdrożeniem szablonu maszyny wirtualnej przejrzyjmy zawartość, aby zrozumieć jej strukturę.

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

Ostrzeżenie

Dane użytkownika nie będą szyfrowane, a żaden proces na maszynie wirtualnej może wykonywać zapytania dotyczące tych danych. Nie należy przechowywać poufnych informacji w danych użytkownika. Aby uzyskać więcej informacji, zobacz Najlepsze rozwiązania dotyczące zabezpieczeń i szyfrowania danych platformy Azure.

Po przejrzeniu i zapisaniu pliku szablonu o nazwie virtual-machine-bicep-template.bicepprzejdź do następnej sekcji, aby wdrożyć szablon.

Wdrażanie szablonu

  1. Utwórz plik o nazwie virtual-machine-parameters.json i dodaj wymagane parametry w formacie JSON. Poniższy przykład można użyć jako punktu początkowego. Przedstawione wartości zastąp własnymi.
{
    "$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. Wdrażanie szablonu.
    az deployment group create --resource-group myResourceGroup --template-file virtual-machine-bicep-template.bicep --parameters @virtual-machine-parameters.json

Przeglądanie wdrożonych zasobów

Po zakończeniu wdrażania możesz wyświetlić zasoby przy użyciu interfejsu wiersza polecenia lub witryny Azure Portal.

Aby wyświetlić szczegóły klastra myNexusVirtualMachine w myResourceGroup grupie zasobów, wykonaj następujące czynności

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

Czyszczenie zasobów

Gdy grupa zasobów nie jest już potrzebna, usuń ją. Grupa zasobów i wszystkie zasoby w grupie zasobów zostaną usunięte.

Użyj polecenia az group delete, aby usunąć grupę zasobów, maszynę wirtualną i wszystkie powiązane zasoby z wyjątkiem zasobów sieciowych Operator Nexus.

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

Następne kroki

Pomyślnie utworzono maszynę wirtualną Nexus. Teraz możesz użyć maszyny wirtualnej do hostowania funkcji sieci wirtualnej (VNFs).