Create-ProfileContext.ps1<\/em>, illustrates this process.<\/p>\n # Path to demos - Set this to where you want to store your code\r\n $dir = \u2019C:\\PowerShell\\PSAzure-Module\\PSAzure-Examples\u2019\r\n Set-Location $dir\r\n # First login manually\r\n Connect-AzureRmAccount\r\n # Now save your context locally (Force will overwrite if there)\r\n $path = \"$dir\\ProfileContext.ctx\"\r\n Save-AzureRmContext -Path $path -Force<\/pre>\nThe first thing I do in every script is to set my current location, i.e. where the scripts will be executing from. As stated in the previous section, the samples assume you have a folder named C:\\PowerShell<\/em> and put the module in a subfolder called PSAzure-Module<\/em>. You can of course alter this, just be aware that each script in the PSAzure-Demo<\/em> as well as PSAzure-Examples<\/em> has a directory variable at the top you\u2019ll need to update this to reflect your install location.<\/p>\nWith that in place, the next step is to login to Azure, if you aren\u2019t already. That\u2019s where the Connect-AzureRMAccount<\/strong> cmdlet comes in. This is part of the AzureRM<\/em> module, and, if not logged in, it will bring up a web form and ask for your credentials.<\/p>\nOnce logged in, you then set up the location to save your credentials to. The example above uses ProfileContext.ctx,<\/em> the default filename in the PSAzure module. You can of course override. Finally, the Save-AzureRmContext<\/strong> cmdlet writes your credentials out to disk. You should save the context file in the same folder with the scripts you want to execute. For this article, that would be the PSAzure-Examples<\/em> folder.<\/p>\nNOTE: You need to be very careful with this method. If someone were to access your machine with your file, they could use your credentials to access your Azure account. For a learner working with their own MSDN account, for example, it should work fine.<\/p>\n
From here on, prior to running any Azure related code, you\u2019ll just need to run the function Connect-PSToAzure<\/strong> as long as your current path is the directory where the context file is saved, <\/em>and it will log you in using the context file you just created. See the help for this function for more information on valid locations to store the file and how to override both the folder and file name it can use for auto login.<\/p>\nDiscovering Your VM Options<\/h2>\n
In order to create your VM in Azure, you must first gather information about what you want to create. There are two basic things you need to provide: what image you want and how big you want the VM to be. You can think of the image as if it were an ISO or DVD used to install an operating system and software. You provide a combination of information to Azure that it can use to retrieve the virtual ISO that you want. The second item you must specify is the virtual hardware configuration. How much RAM, disk space, etc. The script Get-AzureVMOptions.ps1<\/em>, found in the examples folder of the PSAzure module, demonstrates how to retrieve this information.<\/p>\nAs the options vary by region, you need to begin by determining the location. For making code reusable, this is generally put in a variable.<\/p>\n
$location = 'southcentralus'<\/pre>\nYou then get a list of publishers. Publishers are the various companies who put images on Azure that are the basis for virtual machines.<\/p>\n
Get-AzureRmVMImagePublisher -Location $location <\/pre>\nThis winds up being a huge list. It\u2019s great so many companies have embraced the Azure platform! You will want to limit the list a bit to make it easier to find what you want.<\/p>\n
Get-AzureRmVMImagePublisher -Location $location |\r\n Select-Object PublisherName |\r\n Where-Object PublisherName -Like 'Microsoft*' <\/pre>\nGreat, a nice short list — of about 90 entries. Here are the last few items in the list:<\/p>\n
MicrosoftRServer MicrosoftSharePoint MicrosoftSQLServer MicrosoftVisualStudio MicrosoftWindowsDesktop MicrosoftWindowsServer MicrosoftWindowsServerHPCPack<\/p>\n
For this example, select SQL Server as the publisher.<\/p>\n
$publisher = 'MicrosoftSQLServer'<\/pre>\nWith the publisher determined, you need to see all the various images that are available for this publisher.<\/p>\n
Get-AzureRmVMImageOffer -Location $location -PublisherName $publisher<\/pre>\nFor brevity a few columns have been excluded from the result set recreated here.<\/p>\n
![](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/2018\/04\/word-image-172.png\")
<\/p>\n
This presents a list with a variety of SQL Servers, such as 2012, 2014, 2016, and so on. In addition, the offer includes the platform, such as Windows Server 2012 or 2016. For this example, pick SQL Server 2016, Service Pack 1, on a Windows Server 2016 platform.<\/p>\n
$offer = 'SQL2016SP1-WS2016'<\/pre>\nThe next step is to indicate specifically which product in the SQL Server offering you want, i.e., Enterprise, Standard, or Development. To get a list, you can retrieve the SKUs available for this offer.<\/p>\n
Get-AzureRmVMImageSku -Location $location `\r\n -PublisherName $publisher `\r\n -Offer $offer<\/pre>\nMost of these entries should seem familiar to you if you work in the SQL Server world.<\/p>\n
![](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/2018\/04\/word-image-173.png\")
<\/p>\n
For the purposes of this article, use the SQLDEV SKU.<\/p>\n
$sku = 'SQLDEV'<\/pre>\nYou need one more piece of information to finalize the exact version of SQL Server Developer, and that is the version number.<\/p>\n
Get-AzureRmVMImage -Location $location `\r\n -PublisherName $publisher `\r\n -Offer $offer `\r\n -Sku $sku<\/pre>\nThis will return a list of versions (again a few columns were trimmed for space purposes).<\/p>\n
![](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/2018\/04\/word-image-174.png\")
<\/p>\n
For example, 13.0.500110 is one of the versions available for SQL Server 2016 Developer. You could also choose to use \u2018latest\u2019 and Azure will use the most recent version of the image. In general, using the latest option is generally the method to use, unless you have reasons for a specific version.<\/p>\n
At this point, you have all the information you need to get the image, in other words that \u2018virtual ISO\u2019, but not to create the VM. Now that you know the software for the VM, you must choose the virtual hardware.<\/p>\n
Get-AzureRmVMSize -Location $location <\/pre>\nSince the list has over 150 options, just the first few rows are shown below.<\/p>\n
![](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/2018\/04\/word-image-175.png\")
<\/p>\n
The cmdlet above returns a list of configuration names, and for each one the number of cores, amount of memory, and more. Look over the list to find a size that works for you. For our example, we\u2019ll use a small size.<\/p>\n
$vmSize = 'Basic_A3' <\/pre>\nWith that you now have the information you need to create your VM. While you could garner this information through the Azure user website, using PowerShell ensures you get the exact strings you need to pass into the PSAzure module.<\/p>\n
Laying the Base<\/h2>\n
The sample file Create-AzureVM.ps1,<\/em> located in the PSAzure-Examples<\/em> folder, contains the example code that calls the necessary functions within the PSAzure<\/em> module to create a virtual machine. Recreating each line of code here would make this article far too long. I will instead call out key highlights. You should open the file in the PowerShell ISE or another editor, so you can follow along. Be aware that the script does have some extra code just for demonstration purposes. If you decide to adapt this script for creating your own VM\u2019s, you\u2019ll want to strip this out. Additionally, there are some variables to set things like resource and account names that you should customize for your environment.<\/p>\nYou can create the Azure objects by running the code in the remaining sections, but you will need to change some variable values. Note that also that I\u2019ll show code here that demonstrates how the functions within the module works. These code snippets will each have a comment, so you will know not to copy and run them.<\/p>\n
The sample starts by setting a few variables. All the objects created in the samples use AzurePSTest<\/strong> at the beginning of their name. As just mentioned, you will want to update these for your purposes. If you are a student, perhaps change the AzurePSTest<\/strong> text to YourNameHerePSTest<\/strong>, or in a corporate environment use a variation on your company name.<\/p>\nAfter setting the variables, a new resource group is created. Except for a slight name change, the code is the same as the new resource group routine from the article mentioned above, PowerShell Functions for Reusablity and Restartability in Azure.<\/p>\n
$resourceGroup = 'AzurePSTestRG'\r\n $location = 'southcentralus'\r\n $storageAccount = 'azurepsteststorageacct'\r\n New-PSResourceGroup -ResourceGroupName $resourceGroup -Location $location<\/pre>\nAll virtual machines need to be stored somewhere in Azure. The logical place is in Azure storage. Before you go creating new that new storage account, there are some rules that need to be followed with naming storage accounts. Fortunately, the PSAzure module has some functions to aid you. The first concerns naming; storage account names must be between 3 and 24 characters in length, be numbers or lowercase letters only, with no punctuation or other characters.<\/p>\n
You can use the PSAzure<\/em> function Test-PSAzureValidStorageAccountName<\/strong> to validate that the name is correct. The function returns an object with two properties. The first is Valid<\/strong>, a Boolean that indicates true for a valid name, or false for invalid. The second is Reason<\/strong>, a text string which contains which rules the name violated.<\/p>\nIn the example below, there is a hard coded a valid name, so for the Create-AzureVM.ps1<\/em> script this isn\u2019t really needed. However, you may wish to adapt the example script to accept parameters. Should that be the case, the ability to test for a valid name will be valuable.<\/p>\n $storageAccount = 'azurepsteststorageacct'\r\n $isValid = Test-PSAzureValidStorageAccountName `\r\n -StorageAccountName $storageAccount\r\n \"Valid Storage Account = $($isValid.Valid)\"\r\n \"Reason: $($isValid.Reason)\"\r\n <\/pre>\nBehind the scenes, the function is very straightforward. It calls no functions related to Azure from the AzureRM<\/em> module. It is just a series of checks using string properties and methods such as Length<\/strong> and ToLower()<\/strong>. Even if you\u2019ve only done basic PowerShell coding, you should find the code easy to understand, so I\u2019ll leave it to you to dive in deeper.<\/p>\nThe next concern is storage account name availability. Storage account names must be unique across all of Azure. You read that correctly! Across all the Azure storage accounts all around the world, the name you choose must be unique. There are many suggestions for creating unique names. You could use some combination of company, department, application, and a number. Alternatively, you could include a GUID in the name (PowerShell\u2019s New-Guid<\/strong> cmdlet could help you here).<\/p>\nWhatever naming convention you arrive at, you\u2019ll want to ensure the name is available. Within PSAzure<\/em>, there is a function named Test-PSStorageAccountNameAvailability<\/strong> that will return a true if the name is available or false if someone else is already using the name.<\/p>\n $saAvailable = Test-PSStorageAccountNameAvailability `\r\n -StorageAccountName $storageAccount\r\n Write-Host \"Is the name available? $saAvailable\" <\/pre>\nWithin the function, the AzureRM<\/em> cmdlet Get-AzureRmStorageAccountNameAvailability<\/strong> is called. The cmdlet returns an object with several properties, so the function Test-PSStorageAccountNameAvailability<\/strong> takes care of accessing the correct property and returning true if the storage account name is available, or false if someone else has taken it already. Be warned, this function can take a long time to run. It needs to check across all of Azure, so it can take several minutes to execute.<\/p>\nWhat if your naming convention is such that you are certain the name won\u2019t be in use elsewhere? You may just wish to test to see if the storage account name already exists within the confines of your resource group. PSAzure<\/em> can help here, too, with the function Test-PSStorageAccount<\/strong>.<\/p>\n $saExists = Test-PSStorageAccount `\r\n -StorageAccountName $storageAccount `\r\n -ResourceGroupName $resourceGroup `\r\n -Location $location\r\n Write-Host \"Does the account already exist in our environment? $saExists\"<\/pre>\nThis function uses the AzureRM<\/em> cmdlet Get-AzureRMStorageAccount<\/strong> to return a list of the storage accounts that match the name, resource group, and location passed in as parameters. If anything is found it will return a value of true, otherwise false.<\/p>\nOnce you have verified you have a storage account name that is valid, not in use, and not already in your resource group, you are ready to create it. PSAzure<\/em> has a function New-PSStorageAccount<\/strong> to create an account to store VM. You could of course use a storage account that already exists, but for this example you\u2019ll create a new one.<\/p>\n New-PSStorageAccount -StorageAccountName $storageAccount `\r\n -ResourceGroupName $resourceGroup `\r\n -Location $location `\r\n -Verbose\r\n <\/pre>\nBehind the scenes, the function first checks to see if a storage account by the name passed in, in this case azurepsteststoreageacct<\/em><\/strong>, already exists. It does so by calling the Test-PSStorageAccount<\/strong> function that was just discussed. This value is returned into a variable, $saExists<\/strong>. If the storage account doesn\u2019t exist, the variable will be false. The next bit of code found inside the function checks this, and, if it is false, creates the storage account.<\/p>\n# function code, do not run\r\nif ($saExists -eq $false)\r\n{\r\n Write-Verbose \"$fn Creating Storage Account $StorageAccountName\"\r\n New-AzureRmStorageAccount -ResourceGroupName $ResourceGroupName `\r\n -Name $StorageAccountName `\r\n -Location $Location `\r\n -Type Standard_LRS\r\n}<\/pre>\nVirtual Networking<\/h2>\n
Creating a virtual machine is great, but it won\u2019t be of much use unless it can communicate outside of itself. That\u2019s where virtual networking comes in. To setup a virtual network, often abbreviated vnet, you need to accomplish three things. First is the creation of the virtual network itself. After the network is created, you need to define a security group for it. In essence, the security group defines a firewall. In the process of creating it, the PSAzure<\/em> module automatically creates firewall rules that allow HTTP and RDP (Remote Desktop Protocol) traffic through the firewall. There are functions in PSAzure<\/em> to create security groups at a lower level, allowing one to create alternate rules. This example will demonstrate the most common options.<\/p>\nThe final step is to create a virtual NIC, or Network Interface Card. The NIC will form the bridge between the virtual network and the virtual machine, much like a physical network card allows a physical computer to connect to a real network. First off, a few variables are assigned. These will hold names for the security group, network and subnet names. The network addresses for the main network and subnet are also placed into into variables. Finally, a name is assigned to the NIC.<\/p>\n
$networkSecurityGroup = 'AzurePSTestSecurityGroup'\r\n $networkName = 'AzurePSTestNetwork'\r\n $networkAddress = '192.168.0.0\/16'\r\n $subnetName = 'AzurePSTestNetworkSubnet'\r\n $subnetAddress = '192.168.1.0\/24'\r\n $nicName = 'ArcanePSTestNIC'<\/pre>\nWith variables created, it\u2019s time for the first step: creating the virtual network. The PSAzure<\/em> module has a function, New-PSAzureVirtualNetwork<\/strong>, to handle this.<\/p>\n New-PSAzureVirtualNetwork -ResourceGroupName $resourceGroup `\r\n -VirtualNetworkName $networkName `\r\n -VirtualSubnetName $subnetName `\r\n -VirtualNetworkAddress $networkAddress `\r\n -VirtualSubnetAddress $subnetAddress `\r\n -Location $location `\r\n -Verbose<\/pre>\nLike other functions, this one checks to see if the virtual network already exists. If not, the logic flows into an if<\/strong> statement to create the new virtual network.<\/p>\n# function code, do not run\r\n$vNetExists = Test-PSAzureVirtualNetwork `\r\n -ResourceGroupName $ResourceGroupName `\r\n -Name $VirtualNetworkName\r\nif ($vNetExists -eq $false)\r\n{\r\n \u2026<\/pre>\nNext, the subnet is created inside the function. To be more accurate, it\u2019s a subnet configuration. At this point nothing has been created on Azure. Instead a subnet configuration object has been created and stored in the $subnetConfig<\/strong> variable.<\/p>\n # function code, do not run \r\n $subnetConfig = New-AzureRmVirtualNetworkSubnetConfig `\r\n -Name $VirtualSubnetName `\r\n -AddressPrefix $VirtualSubnetAddress<\/pre>\nWith this configuration now created, the virtual network can be generated on Azure. The network name and address are passed in, along with the subnet configuration object that was just created.<\/p>\n
# function code, do not run \r\nNew-AzureRmVirtualNetwork -ResourceGroupName $ResourceGroupName `<\/span>\r\n -Name $VirtualNetworkName `\r\n -AddressPrefix $VirtualNetworkAddress `\r\n -Subnet $subnetConfig `\r\n -Location $Location<\/pre>\nThe next step is to create the security group. The PSAzure<\/em> module has a function to do just that.<\/p>\nNew-PSAzureNetworkSecurityGroup -ResourceGroupName $resourceGroup `\r\n -NetworkSecurityGroupName $networkSecurityGroup `\r\n -Location $location `\r\n -Verbose\r\n <\/pre>\nWithin the function, the code checks to see if the security group already exists. To do so, it uses another function within the module, Test-PSAzureNetworkSecurityGroup<\/strong>. The code inside is much like the others, it checks to see if the object exists, then returns true or false.<\/p>\n# function code, do not run\r\n$exists = Test-PSAzureNetworkSecurityGroup `\r\n -ResourceGroupName $ResourceGroupName `\r\n -NetworkSecurityGroupName $NetworkSecurityGroupName<\/pre>\nIf the security group is not present, the function goes into an if statement. The first thing that happens is the creation of some security rule objects.<\/p>\n
# function code, do not run\r\n$rdpRule = New-PSAzureRdpSecurityRule$httpRule = New-PSAzureHttpSecurityRule<\/pre>\nNote it has created the rules as objects and placed them into variables. Much like the creation of the subnet configuration, these objects will be used later. Because the RDP and HTTP rules are used so much, PSAzure<\/em> has specific functions to create them. They are similar, so just review the one for generating the RDP rule.<\/p>\n# function code, do not run\r\n$rdpRule = New-PSAzureSecurityRule -RuleName 'rdp-rule' `\r\n -RuleDescription 'Allow RDP' `\r\n -Priority 100 `\r\n -Port 3389return $rdpRule<\/pre>\nSimilar, and simple. This creates a new security rule, with the appropriate settings. RDP uses port 3389; in the HTTP version of the function, port 80 is used. The new rule object is returned to be stored in the variables you saw a moment ago. With that complete, the function can now create the actual security group in Azure.<\/p>\n
# function code, do not run\r\nNew-AzureRmNetworkSecurityGroup `\r\n -ResourceGroupName $ResourceGroupName `\r\n -Location $Location `\r\n -Name $NetworkSecurityGroupName `\r\n -SecurityRules $rdpRule, $httpRule<\/pre>\nWith the security group created, two of the three steps to create the virtual network setup for the VM are completed. The final step is to create the virtual network card. The function within the PSAzure module to do this is New-PSAzureVirtualNIC<\/strong>.<\/p>\n New-PSAzureVirtualNIC -ResourceGroupName $resourceGroup `\r\n -NICName $nicName `\r\n -VirtualNetworkName $networkName `\r\n -NetworkSecurityGroupName $networkSecurityGroup `\r\n -Location $location `\r\n -Verbose<\/pre>\nFollowing the pattern of the other functions, it calls a test function to see if the NIC already exists.<\/p>\n
# function code, do not run \r\n $exists = Test-PSAzureVirtualNIC -ResourceGroupName $ResourceGroupName `\r\n -NICName $NICName<\/pre>\nIf not, it then calls an AzureRM function to create the network interface card.<\/p>\n
# function code, do not run \r\n $result = Get-AzureRmNetworkInterface `\r\n -ResourceGroupName $ResourceGroupName `\r\n -Name $NICName<\/pre>\nSummary<\/h2>\n
In this article you laid the foundation for creating Azure Virtual Machines. You saw how to make the login process easier, followed by how to determine what virtual machine images are available. More importantly, the code returned the exact values that must be used in order to generate a virtual machine with that image.<\/p>\n
Several fundamental steps came next: creating a resource group and storage account to hold the VM; the creation of the network components; a virtual network was generated; a security group laid on it that defined firewall rules; and, finally, a virtual NIC was created, which will act as a bridge between the virtual network and the virtual machine.<\/p>\n
In the next article<\/a> you\u2019ll actually create the virtual machine. Additionally, you\u2019ll see how to automate the generation of an RDP file to make remoting into the virtual machine easy. The next article will also show the stop and start functions built into the PSAzure<\/em> module, so the machine can be set to only run when it needs to, saving you and your company money. As a final step, you\u2019ll see how to remove everything that was created.<\/p>\n","protected":false},"excerpt":{"rendered":"Azure virtual machines are created for many reasons, even just to have an environment to quickly test something out. In this article, Robert Cain demonstrates the first few steps in automating the process with PowerShell. He shows how to gather information needed and set up a resource group, storage and networking needed for the VM. …<\/p>\n","protected":false},"author":316962,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[143513,35],"tags":[95506],"coauthors":[52865],"class_list":["post-78393","post","type-post","status-publish","format-standard","hentry","category-containers-and-virtualization","category-powershell","tag-automate"],"acf":[],"_links":{"self":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/78393","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/users\/316962"}],"replies":[{"embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/comments?post=78393"}],"version-history":[{"count":18,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/78393\/revisions"}],"predecessor-version":[{"id":88828,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/78393\/revisions\/88828"}],"wp:attachment":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/media?parent=78393"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/categories?post=78393"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/tags?post=78393"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/coauthors?post=78393"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
![](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/2018\/04\/word-image-170.png\")
<\/p>\n![](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/2018\/04\/word-image-171.png\")
<\/p>\n![\"C:\\Users\\arcan\\AppData\\Local\\Temp\\SNAGHTMLdebd6c.PNG\"](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/2018\/04\/c-users-arcan-appdata-local-temp-snaghtmldebd6c-p.png\")
<\/p>\n