Deploy 3 Virtual Machines on Azure

Introduction

In this solution, we will create three virtual machines (VMs) on Microsoft Azure using Pulumi with TypeScript. Pulumi is an Infrastructure as Code (IaC) tool that allows you to define and manage cloud resources using familiar programming languages. This approach provides the benefits of version control, code reuse, and automation. The key services involved in this solution are Azure Virtual Machines, Azure Virtual Network, and Azure Network Security Group.

Step-by-Step Explanation

Step 1: Set Up Pulumi Project

First, we need to set up a new Pulumi project. This involves initializing a new Pulumi project and configuring the necessary Azure provider.

Step 2: Create Azure Resource Group

We will create an Azure Resource Group to organize and manage the resources we will be deploying.

Step 3: Create Virtual Network and Subnet

Next, we will create an Azure Virtual Network (VNet) and a subnet within the VNet. This will provide the networking infrastructure for our VMs.

Step 4: Create Network Security Group

We will create a Network Security Group (NSG) to control inbound and outbound traffic to our VMs.

Step 5: Create Virtual Machines

Finally, we will create three Azure Virtual Machines within the subnet. Each VM will be associated with the NSG to ensure proper network security.

Key Points

• Pulumi Project: Initialize and configure a Pulumi project for Azure.
• Resource Group: Create a resource group to manage resources.
• Virtual Network: Set up a virtual network and subnet for networking.
• Network Security Group: Implement network security using NSG.
• Virtual Machines: Deploy three virtual machines within the subnet.

Conclusion

By following this solution, we have successfully created three virtual machines on Azure using Pulumi with TypeScript. This approach demonstrates the power and flexibility of using Pulumi for Infrastructure as Code, allowing for efficient and automated cloud resource management. The key services involved, such as Azure Virtual Machines, Virtual Network, and Network Security Group, play a crucial role in ensuring a secure and scalable infrastructure.

Full Code Example

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure-native";

// Create an Azure Resource Group
const resourceGroup = new azure.resources.ResourceGroup("resourceGroup", {
    resourceGroupName: "myResourceGroup",
    location: "WestUS",
});

// Create a Virtual Network
const virtualNetwork = new azure.network.VirtualNetwork("virtualNetwork", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    addressSpace: { addressPrefixes: ["10.0.0.0/16"] },
});

// Create a Subnet
const subnet = new azure.network.Subnet("subnet", {
    resourceGroupName: resourceGroup.name,
    virtualNetworkName: virtualNetwork.name,
    addressPrefix: "10.0.1.0/24",
});

// Create a Network Security Group
const networkSecurityGroup = new azure.network.NetworkSecurityGroup("networkSecurityGroup", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    securityRules: [{
        name: "AllowSSH",
        priority: 1000,
        direction: "Inbound",
        access: "Allow",
        protocol: "Tcp",
        sourcePortRange: "*",
        destinationPortRange: "22",
        sourceAddressPrefix: "*",
        destinationAddressPrefix: "*",
    }],
});

// Create Network Interfaces and Virtual Machines
const vmNames = ["vm1", "vm2", "vm3"];
const virtualMachines = vmNames.map((vmName, index) => {
    const networkInterface = new azure.network.NetworkInterface(`${vmName}-nic`, {
        resourceGroupName: resourceGroup.name,
        location: resourceGroup.location,
        ipConfigurations: [{
            name: "ipconfig1",
            subnet: { id: subnet.id },
            privateIPAllocationMethod: "Dynamic",
            publicIPAddress: { id: new azure.network.PublicIPAddress(`${vmName}-pip`, {
                resourceGroupName: resourceGroup.name,
                location: resourceGroup.location,
                publicIPAllocationMethod: "Dynamic",
            }).id },
        }],
        networkSecurityGroup: { id: networkSecurityGroup.id },
    });

    return new azure.compute.VirtualMachine(vmName, {
        resourceGroupName: resourceGroup.name,
        location: resourceGroup.location,
        networkProfile: { networkInterfaces: [{ id: networkInterface.id }] },
        hardwareProfile: { vmSize: "Standard_DS1_v2" },
        osProfile: {
            computerName: vmName,
            adminUsername: "adminuser",
            adminPassword: "Password1234!",
        },
        storageProfile: {
            imageReference: {
                publisher: "Canonical",
                offer: "UbuntuServer",
                sku: "18.04-LTS",
                version: "latest",
            },
            osDisk: {
                createOption: "FromImage",
            },
        },
    });
});

export const resourceGroupName = resourceGroup.name;
export const virtualNetworkName = virtualNetwork.name;
export const subnetName = subnet.name;
export const networkSecurityGroupName = networkSecurityGroup.name;
export const virtualMachineNames = virtualMachines.map(vm => vm.name);