Utilisez les kits SDK Azure pour créer une machine virtuelle

Utilisez les kits SDK Azure pour créer et supprimer une machine virtuelle Azure.

Configurer votre environnement de développement

• Compte d’utilisateur Azure avec un abonnement actif. Créez-en un gratuitement.
• Node.js LTS avec NPM, le gestionnaire de package Node.js installé sur votre machine locale.
• Visual Studio Code installé sur votre ordinateur local.
• Créez un principal de service et copiez les Tenant Id, Client ID, Client secret.
• Utilisez la page des abonnements du portail Azure pour rechercher votre ID d’abonnement, puis copiez cette valeur à utiliser dans ces scripts.

Machines virtuelles Azure

Une machine virtuelle Azure demande plusieurs ressources pour prendre en charge la machine virtuelle. La meilleure façon de gérer ces ressources consiste à créer toutes les ressources dans un seul groupe de ressources. Le script crée le groupe de ressources et ajoute un nombre aléatoire pour s’assurer que le groupe de ressources est unique, quel que soit le nombre de fois où vous utilisez le script.

Les ressources créées dans ces scripts sont les suivantes :

• Resource group
• Machines virtuelles
• Stockage
• Réseau virtuel
  • Interface réseau
  • Adresse IP publique

Création d'une machine virtuelle

1. Créez un fichier appelé create-vm.js ou copiez le fichier depuis 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);
     });
   

   Les méthodes de SDK utilisées dans ce script sont les suivantes :

   • Groupes de ressources
     • resourceClient.resourcegroups.createOrUpdate
   • Stockage
     • storageClient.storageAccounts.create
   • Réseaux
     • networkClient.virtualNetworks.createOrUpdate
     • networkClient.subnets.get
     • networkClient.publicIPAddresses.createOrUpdate
     • networkClient.networkInterfaces.createOrUpdate
     • networkClient.networkInterfaces.get
   • Vms
     • computeClient.virtualMachines.createOrUpdate
     • computeClient.virtualMachineImages.list

2. Installez les packages npm utilisés dans le travail Azure :

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

3. Pour le développement local, changez les variables dans le fichier pour l’authentification :

   // 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";    
   

4. Changez les variables pour le nommage des ressources :

   // 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"
   

5. Exécutez le code pour créer une machine virtuelle :

   node create-vm.js
   

   La sortie contient le nom du groupe de ressources :

   success - resource group name: johnsmith-testrg1689
   

Nettoyer les ressources

Une fois que vous avez terminé avec la machine virtuelle, supprimez le groupe de ressources.

1. Créez un fichier appelé delete-resources.js ou copiez le fichier depuis 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);
     });
   

2. Pour le développement local, changez les variables dans le fichier pour l’authentification :

   // 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";    
   

3. Récupérez le nom du groupe de ressources, qui a été retourné en tant que dernière ligne du script de création, puis changez la variable dans le script de suppression :

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

4. Exécutez le code pour créer une machine virtuelle :

   node delete-resources.js
   

   La suppression peut prendre quelques minutes.

   Les méthodes de SDK utilisées dans ce script sont les suivantes :

   • Groupes de ressources - resourceClient.resourcegroups.delete

Étapes suivantes

• Créer une machine virtuelle avec Azure CLI et un fichier cloud-init
• Sélection de l’hébergement pour votre application