Usare gli SDK di Azure per creare una macchina virtuale

Articolo
10/21/2023

Usare gli SDK di Azure per creare ed eliminare una macchina virtuale di Azure.

Configurare l'ambiente di sviluppo

Un account utente di Azure con una sottoscrizione attiva. Crearne una gratuitamente.
Node.js LTS con NPM, la gestione pacchetti Node.js installata nel computer locale.
Visual Studio Code installato nel computer locale.
Creare un'entità servizio e copiare , Tenant Id. Client IDClient secret
Usare la pagina di sottoscrizione di portale di Azure per trovare l'ID sottoscrizione, copiare tale valore da usare in questi script.

Macchine virtuali di Azure

Una macchina virtuale di Azure richiede diverse risorse per supportare la macchina virtuale. Il modo migliore per gestire tali risorse consiste nel creare tutte le risorse in un singolo gruppo di risorse. Lo script crea il gruppo di risorse e antepone un numero casuale per assicurarsi che il gruppo di risorse sia univoco, indipendentemente dal numero di volte in cui si usa lo script.

Le risorse create in questi script includono:

Gruppo di risorse
Macchine virtuali
Storage
Rete virtuale
- Interfaccia di rete
- Indirizzo IP pubblico

Creare una macchina virtuale

Creare un file denominato create-vm.js o copiare il file da GitHub.

const util = require("util");
const {
  ClientSecretCredential,
  DefaultAzureCredential,
} = require("@azure/identity");
const { ComputeManagementClient } = require("@azure/arm-compute");
const { ResourceManagementClient } = require("@azure/arm-resources");
const { StorageManagementClient } = require("@azure/arm-storage");
const { NetworkManagementClient } = require("@azure/arm-network");

// Store function output to be used elsewhere
let randomIds = {};
let subnetInfo = null;
let publicIPInfo = null;
let vmImageInfo = null;
let nicInfo = null;

// CHANGE THIS - used as prefix for naming resources
const yourAlias = "diberry";

// CHANGE THIS - used to add tags to resources
const projectName = "azure-samples-create-vm";

// Resource configs
const location = "eastus";
const accType = "Standard_LRS";

// Ubuntu config for VM
const publisher = "Canonical";
const offer = "UbuntuServer";
const sku = "14.04.3-LTS";
const adminUsername = "notadmin";
const adminPassword = "Pa$$w0rd92";

// Azure authentication in environment variables for DefaultAzureCredential
const tenantId =
  process.env["AZURE_TENANT_ID"] || "REPLACE-WITH-YOUR-TENANT-ID";
const clientId =
  process.env["AZURE_CLIENT_ID"] || "REPLACE-WITH-YOUR-CLIENT-ID";
const secret =
  process.env["AZURE_CLIENT_SECRET"] || "REPLACE-WITH-YOUR-CLIENT-SECRET";
const subscriptionId =
  process.env["AZURE_SUBSCRIPTION_ID"] || "REPLACE-WITH-YOUR-SUBSCRIPTION_ID";

let credentials = null;

if (process.env.production) {
  // production
  credentials = new DefaultAzureCredential();
} else {
  // development
  credentials = new ClientSecretCredential(tenantId, clientId, secret);
  console.log("development");
}
// Azure services
const resourceClient = new ResourceManagementClient(
  credentials,
  subscriptionId
);
const computeClient = new ComputeManagementClient(credentials, subscriptionId);
const storageClient = new StorageManagementClient(credentials, subscriptionId);
const networkClient = new NetworkManagementClient(credentials, subscriptionId);

// Create resources then manage them (on/off)
async function createResources() {
  try {
    result = await createResourceGroup();
    accountInfo = await createStorageAccount();
    vnetInfo = await createVnet();
    subnetInfo = await getSubnetInfo();
    publicIPInfo = await createPublicIP();
    nicInfo = await createNIC(subnetInfo, publicIPInfo);
    vmImageInfo = await findVMImage();
    nicResult = await getNICInfo();
    vmInfo = await createVirtualMachine(nicInfo.id, vmImageInfo[0].name);
    return;
  } catch (err) {
    console.log(err);
  }
}

async function createResourceGroup() {
  console.log("\n1.Creating resource group: " + resourceGroupName);
  const groupParameters = {
    location: location,
    tags: { project: projectName },
  };
  const resCreate = await resourceClient.resourceGroups.createOrUpdate(
    resourceGroupName,
    groupParameters
  );
  return resCreate;
}

async function createStorageAccount() {
  console.log("\n2.Creating storage account: " + storageAccountName);
  const createParameters = {
    location: location,
    sku: {
      name: accType,
    },
    kind: "Storage",
    tags: {
      project: projectName,
    },
  };
  return await storageClient.storageAccounts.beginCreateAndWait(
    resourceGroupName,
    storageAccountName,
    createParameters
  );
}

async function createVnet() {
  console.log("\n3.Creating vnet: " + vnetName);
  const vnetParameters = {
    location: location,
    addressSpace: {
      addressPrefixes: ["10.0.0.0/16"],
    },
    dhcpOptions: {
      dnsServers: ["10.1.1.1", "10.1.2.4"],
    },
    subnets: [{ name: subnetName, addressPrefix: "10.0.0.0/24" }],
  };
  return await networkClient.virtualNetworks.beginCreateOrUpdateAndWait(
    resourceGroupName,
    vnetName,
    vnetParameters
  );
}

async function getSubnetInfo() {
  console.log("\nGetting subnet info for: " + subnetName);
  const getResult = await networkClient.subnets.get(
    resourceGroupName,
    vnetName,
    subnetName
  );
  return getResult;
}

async function createPublicIP() {
  console.log("\n4.Creating public IP: " + publicIPName);
  const publicIPParameters = {
    location: location,
    publicIPAllocationMethod: "Dynamic",
    dnsSettings: {
      domainNameLabel: domainNameLabel,
    },
  };
  return await networkClient.publicIPAddresses.beginCreateOrUpdateAndWait(
    resourceGroupName,
    publicIPName,
    publicIPParameters
  );
}

async function createNIC(subnetInfo, publicIPInfo) {
  console.log("\n5.Creating Network Interface: " + networkInterfaceName);
  const nicParameters = {
    location: location,
    ipConfigurations: [
      {
        name: ipConfigName,
        privateIPAllocationMethod: "Dynamic",
        subnet: subnetInfo,
        publicIPAddress: publicIPInfo,
      },
    ],
  };
  return await networkClient.networkInterfaces.beginCreateOrUpdateAndWait(
    resourceGroupName,
    networkInterfaceName,
    nicParameters
  );
}

async function findVMImage() {
  console.log(
    util.format(
      "\nFinding a VM Image for location %s from " +
        "publisher %s with offer %s and sku %s",
      location,
      publisher,
      offer,
      sku
    )
  );
  const listResult = new Array();
  for await (const item of computeClient.virtualMachineImages.list(
    location,
    publisher,
    offer,
    sku
  )) {
    listResult.push(item);
  }
  return listResult;
}

async function getNICInfo() {
  return await networkClient.networkInterfaces.get(
    resourceGroupName,
    networkInterfaceName
  );
}

async function createVirtualMachine() {
  const vmParameters = {
    location: location,
    osProfile: {
      computerName: vmName,
      adminUsername: adminUsername,
      adminPassword: adminPassword,
    },
    hardwareProfile: {
      vmSize: "Standard_B1ls",
    },
    storageProfile: {
      imageReference: {
        publisher: publisher,
        offer: offer,
        sku: sku,
        version: vmImageVersionNumber,
      },
      osDisk: {
        name: osDiskName,
        caching: "None",
        createOption: "fromImage",
        vhd: {
          uri:
            "https://" +
            storageAccountName +
            ".blob.core.windows.net/nodejscontainer/osnodejslinux.vhd",
        },
      },
    },
    networkProfile: {
      networkInterfaces: [
        {
          id: nicId,
          primary: true,
        },
      ],
    },
  };
  console.log("6.Creating Virtual Machine: " + vmName);
  console.log(
    " VM create parameters: " + util.inspect(vmParameters, { depth: null })
  );
  const resCreate = await computeClient.virtualMachines.beginCreateOrUpdateAndWait(
    resourceGroupName,
    vmName,
    vmParameters
  );
  return await computeClient.virtualMachines.get(
    resourceGroupName,
    vmName
  );
}

const _generateRandomId = (prefix, existIds) => {
  var newNumber;
  while (true) {
    newNumber = prefix + Math.floor(Math.random() * 10000);
    if (!existIds || !(newNumber in existIds)) {
      break;
    }
  }
  return newNumber;
};

//Random number generator for service names and settings
const resourceGroupName = _generateRandomId(`${yourAlias}-testrg`, randomIds);
const vmName = _generateRandomId(`${yourAlias}vm`, randomIds);
const storageAccountName = _generateRandomId(`${yourAlias}ac`, randomIds);
const vnetName = _generateRandomId(`${yourAlias}vnet`, randomIds);
const subnetName = _generateRandomId(`${yourAlias}subnet`, randomIds);
const publicIPName = _generateRandomId(`${yourAlias}pip`, randomIds);
const networkInterfaceName = _generateRandomId(`${yourAlias}nic`, randomIds);
const ipConfigName = _generateRandomId(`${yourAlias}crpip`, randomIds);
const domainNameLabel = _generateRandomId(`${yourAlias}domainname`, randomIds);
const osDiskName = _generateRandomId(`${yourAlias}osdisk`, randomIds);

async function main() {
  await createResources();
}

main()
  .then(() => {
    console.log(
      `success - resource group name: ${resourceGroupName}, vm resource name: ${vmName}`
    );
  })
  .catch((err) => {
    console.log(err);
  });

I metodi SDK usati in questo script includono:

Installare i pacchetti npm usati nel lavoro di Azure:

npm init -y && install @azure/identity @azure/arm-compute @azure/arm-network @azure/arm-resources @azure/arm-storage

Per lo sviluppo locale, modificare le variabili nel file per l'autenticazione:

// Azure authentication in environment variables for DefaultAzureCredential
const tenantId =
  process.env["AZURE_TENANT_ID"] || "REPLACE-WITH-YOUR-TENANT-ID";
const clientId =
  process.env["AZURE_CLIENT_ID"] || "REPLACE-WITH-YOUR-CLIENT-ID";
const secret =
  process.env["AZURE_CLIENT_SECRET"] || "REPLACE-WITH-YOUR-CLIENT-SECRET";
const subscriptionId =
  process.env["AZURE_SUBSCRIPTION_ID"] || "REPLACE-WITH-YOUR-SUBSCRIPTION_ID";

Modificare le variabili per la denominazione delle risorse:

// CHANGE THIS - used as prefix for naming resources
const yourAlias = "johnsmith";

// CHANGE THIS - used to add tags to resources
const projectName = "azure-samples-create-vm"

Eseguire il codice per creare una macchina virtuale:
```
node create-vm.js
```
L'output include il nome del gruppo di risorse:
```
success - resource group name: johnsmith-testrg1689
```

Pulire le risorse

Al termine della macchina virtuale, eliminare il gruppo di risorse.

Creare un file denominato delete-resources.js o copiare il file da GitHub.

const {
  ClientSecretCredential,
  DefaultAzureCredential,
} = require("@azure/identity");
const { ResourceManagementClient } = require("@azure/arm-resources");

// Azure authentication in environment variables for DefaultAzureCredential
let credentials = null;
const tenantId =
  process.env["AZURE_TENANT_ID"] || "REPLACE-WITH-YOUR-TENANT-ID";
const clientId =
  process.env["AZURE_CLIENT_ID"] || "REPLACE-WITH-YOUR-CLIENT-ID";
const secret =
  process.env["AZURE_CLIENT_SECRET"] || "REPLACE-WITH-YOUR-CLIENT-SECRET";
const subscriptionId =
  process.env["AZURE_SUBSCRIPTION_ID"] || "REPLACE-WITH-YOUR-SUBSCRIPTION_ID";

const resourceGroupName = "REPLACE-WITH-YOUR-RESOURCE_GROUP-NAME";

if (process.env.production) {
  // production
  credentials = new DefaultAzureCredential();
} else {
  // development
  credentials = new ClientSecretCredential(tenantId, clientId, secret);
  console.log("development");
}

async function deleteResourceGroup() {
  // Create Azure SDK client for Resource Management such as resource groups
  const resourceClient = new ResourceManagementClient(
    credentials,
    subscriptionId
  );

  const result = await resourceClient.resourceGroups.deleteMethod(
    resourceGroupName
  );
  console.log(JSON.stringify(result));
}

deleteResourceGroup()
  .then((result) => {
    console.log(result);
  })
  .catch((ex) => {
    console.log(ex);
  });

Per lo sviluppo locale, modificare le variabili nel file per l'autenticazione:

// Azure authentication in environment variables for DefaultAzureCredential
const tenantId =
  process.env["AZURE_TENANT_ID"] || "REPLACE-WITH-YOUR-TENANT-ID";
const clientId =
  process.env["AZURE_CLIENT_ID"] || "REPLACE-WITH-YOUR-CLIENT-ID";
const secret =
  process.env["AZURE_CLIENT_SECRET"] || "REPLACE-WITH-YOUR-CLIENT-SECRET";
const subscriptionId =
  process.env["AZURE_SUBSCRIPTION_ID"] || "REPLACE-WITH-YOUR-SUBSCRIPTION_ID";

Ottenere il nome del gruppo di risorse, restituito come ultima riga dallo script di creazione e modificare la variabile nello script di eliminazione:
```
const resourceGroupName = "REPLACE-WITH-YOUR-RESOURCE_GROUP-NAME";
```
Eseguire il codice per creare una macchina virtuale:
```
node delete-resources.js
```
L'eliminazione potrebbe richiedere alcuni minuti.

I metodi SDK usati in questo script includono:
- Gruppi di risorse - resourceClient.resourcegroups.delete

Share via

Usare gli SDK di Azure per creare una macchina virtuale

Configurare l'ambiente di sviluppo

Macchine virtuali di Azure

Creare una macchina virtuale

Pulire le risorse

Passaggi successivi

Commenti e suggerimenti

Commenti e suggerimenti

Risorse aggiuntive