private static IVirtualMachine PrepareSpecializedManagedVirtualMachine(IAzure azure, Region region, string rgName)
{
var userName = Utilities.CreateUsername();
var password = Utilities.CreatePassword();
var linuxVmName1 = SdkContext.RandomResourceName("vm" + "-", 10);
var publicIpDnsLabel = SdkContext.RandomResourceName("pip" + "-", 20);
var linuxVM = azure.VirtualMachines.Define(linuxVmName1)
.WithRegion(region)
.WithNewResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithNewPrimaryPublicIPAddress(publicIpDnsLabel)
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername(userName)
.WithRootPassword(password)
.WithNewDataDisk(100)
.WithNewDataDisk(200)
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.Create();
// De-provision the virtual machine
Utilities.DeprovisionAgentInLinuxVM(linuxVM.GetPrimaryPublicIPAddress().Fqdn, 22, userName, password);
Utilities.Log("Deallocate VM: " + linuxVM.Id);
linuxVM.Deallocate();
Utilities.Log("Deallocated VM: " + linuxVM.Id + "; state = " + linuxVM.PowerState);
Utilities.Log("Generalize VM: " + linuxVM.Id);
linuxVM.Generalize();
Utilities.Log("Generalized VM: " + linuxVM.Id);
return(linuxVM);
}
/**
* It creates a new Azure virtual machine and it instantiate a Java Docker client.
* @param azure - instance of Azure
* @param rgName - name of the Azure resource group to be used when creating a virtual machine
* @param region - region to be used when creating a virtual machine
* @return an instance of DockerClient
*/
public static DockerClient FromNewDockerVM(IAzure azure, String rgName, Region region)
{
string dockerVMName = SdkContext.RandomResourceName("dockervm", 15);
string publicIPDnsLabel = SdkContext.RandomResourceName("pip", 10);
string vmUserName = "******";
string vmPassword = Utilities.CreatePassword();
// Could not find a Docker environment; presume that there is no local Docker engine running and
// attempt to configure a Docker engine running inside a new Azure virtual machine
Utilities.Log("Creating an Azure virtual machine running Docker");
IVirtualMachine dockerVM = azure.VirtualMachines.Define(dockerVMName)
.WithRegion(region)
.WithExistingResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithNewPrimaryPublicIPAddress(publicIPDnsLabel)
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername(vmUserName)
.WithRootPassword(vmPassword)
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.Create();
Utilities.Log("Created Azure Virtual Machine: " + dockerVM.Id);
// Get the IP of the Docker host
INicIPConfiguration nicIPConfiguration = dockerVM.GetPrimaryNetworkInterface().PrimaryIPConfiguration;
IPublicIPAddress publicIp = nicIPConfiguration.GetPublicIPAddress();
string dockerHostIP = publicIp.IPAddress;
DockerClient dockerClient = InstallDocker(dockerHostIP, vmUserName, vmPassword);
return(dockerClient);
}
public void CanResetPasswordUsingVMAccessExtension()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
string rgName = TestUtilities.GenerateName("vmexttest");
string location = "eastus";
string vmName = "javavm";
var azure = TestHelper.CreateRollupClient();
try
{
var vm = azure.VirtualMachines
.Define(vmName)
.WithRegion(location)
.WithNewResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer14_04_Lts)
.WithRootUsername("Foo12")
.WithRootPassword("BaR@12abc!")
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.Create();
var availableSizes = vm.AvailableSizes();
vm.Update()
.DefineNewExtension("VMAccessForLinux")
.WithPublisher("Microsoft.OSTCExtensions")
.WithType("VMAccessForLinux")
.WithVersion("1.4")
.WithProtectedSetting("username", "Foo12")
.WithProtectedSetting("password", "B12a6@12xyz!")
.WithProtectedSetting("reset_ssh", "true")
.Attach()
.Apply();
Assert.True(vm.ListExtensions().Count() > 0);
Assert.True(vm.ListExtensions().ContainsKey("VMAccessForLinux"));
vm.Update()
.UpdateExtension("VMAccessForLinux")
.WithProtectedSetting("username", "Foo12")
.WithProtectedSetting("password", "muy!234OR")
.WithProtectedSetting("reset_ssh", "true")
.Parent()
.Apply();
}
finally
{
try
{
azure.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
/**
* Azure Compute sample for managing virtual machine from Managed Service Identity (MSI) enabled virtual machine -
* - Create a virtual machine using MSI credentials from System assigned or User Assigned MSI enabled VM.
*/
public static void Main(string[] args)
{
// This sample required to be run from a MSI (User Assigned or System Assigned) enabled virtual machine with role
// based contributor access to the resource group specified as the second command line argument.
//
// see https://github.com/Azure-Samples/compute-dotnet-manage-user-assigned-msi-enabled-virtual-machine.git
//
string usage = "Usage: dotnet run <subscription-id> <rg-name> [<client-id>]";
if (args.Length < 2)
{
throw new ArgumentException(usage);
}
string subscriptionId = args[0];
string resourceGroupName = args[1];
string clientId = args.Length > 2 ? args[2] : null;
Region region = Region.USWestCentral;
string linuxVMName = SdkContext.RandomResourceName("vm", 30);
string userName = Utilities.CreateUsername();
string password = Utilities.CreatePassword();
//=============================================================
// MSI Authenticate
AzureCredentials msiCredentails = new AzureCredentials(new MSILoginInformation(MSIResourceType.VirtualMachine)
{
UserAssignedIdentityClientId = clientId
}, AzureEnvironment.AzureGlobalCloud);
var azure = Azure
.Configure()
.WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic)
.Authenticate(msiCredentails)
.WithDefaultSubscription();
Console.WriteLine("Selected subscription: " + azure.SubscriptionId);
//=============================================================
// Create a Linux VM using MSI credentials
Console.WriteLine("Creating a Linux VM using MSI credentials");
var virtualMachine = azure.VirtualMachines
.Define(linuxVMName)
.WithRegion(region)
.WithExistingResourceGroup(resourceGroupName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername(userName)
.WithRootPassword(password)
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.Create();
Console.WriteLine($"Created virtual machine using MSI credentials: {virtualMachine.Id}");
}
///GENMHASH:C19382933BDE655D0F0F95CD9474DFE7:DB5E59650C351CEA1A8047EAB8DFA902
public VirtualMachineSizeTypes Size()
{
if (Inner.HardwareProfile != null && Inner.HardwareProfile.VmSize != null)
{
return(Inner.HardwareProfile.VmSize);
}
if (Sku() != null && Sku().Name != null)
{
return(VirtualMachineSizeTypes.Parse(Sku().Name));
}
return(null);
}
private VirtualMachineSizeTypes GetVmSize(string vmSizeName)
{
switch (vmSizeName)
{
case "StandardDS1":
return(VirtualMachineSizeTypes.StandardDS1);
case "StandardDS1V2":
return(VirtualMachineSizeTypes.StandardDS1V2);
case "StandardDS2V2":
return(VirtualMachineSizeTypes.StandardDS2V2);
case "StandardDS3V2":
return(VirtualMachineSizeTypes.StandardDS3V2);
case "StandardDS4":
return(VirtualMachineSizeTypes.StandardDS4);
case "StandardDS4V2":
return(VirtualMachineSizeTypes.StandardDS4V2);
case "StandardD3V2":
return(VirtualMachineSizeTypes.StandardD3V2);
case "StandardD2V2":
return(VirtualMachineSizeTypes.StandardD2V2);
case "StandardF2s":
return(VirtualMachineSizeTypes.StandardF2s);
case "StandardF4s":
return(VirtualMachineSizeTypes.StandardF4s);
case "StandardF4sV2":
return(VirtualMachineSizeTypes.StandardF4sV2);
case "StandardF8sV2":
return(VirtualMachineSizeTypes.StandardF8sV2);
case "StandardF16sV2":
return(VirtualMachineSizeTypes.StandardF16sV2);
case "StandardD16sV3":
return(VirtualMachineSizeTypes.StandardD16sV3);
case "StandardD32sV3":
return(VirtualMachineSizeTypes.StandardD32sV3);
default:
return(VirtualMachineSizeTypes.Parse(vmSizeName));
}
}
public VirtualMachine(AzureConnection connection, SystemMessageContainer container = null, VirtualMachineSizeTypes vmSize = null)
{
azureConnection = connection;
if (vmSize == null)
{
vmSize = VirtualMachineSizeTypes.BasicA1;
}
this.vmSize = vmSize;
messageContainer = (container == null ? new SystemMessageContainer() : container);
}
///GENMHASH:ADBB2BA7D9DA68A975B518B1AED2CBC7:625A4487ABCC03FFC076F2A5FA047ABB
public VirtualMachineSizeTypes VirtualMachineSizeType()
{
if (this.inner.ResourceType != null &&
this.inner.ResourceType.Equals("virtualMachines", System.StringComparison.OrdinalIgnoreCase) &&
this.inner.Name != null)
{
return(VirtualMachineSizeTypes.Parse(this.inner.Name));
}
else
{
return(null);
}
}
static void CheckInputArgs(string[] args)
{
bool invalidOptions = false;
// parse args
var agentConfig = new ArgsOption();
var result = Parser.Default.ParseArguments <ArgsOption>(args)
.WithParsed(options => agentConfig = options)
.WithNotParsed(error => {
Console.WriteLine($"Fail to parse the options: {error}");
invalidOptions = true;
});
if (invalidOptions)
{
return;
}
if (agentConfig.BenchClientListFile != null)
{
Util.Log($"Bench client output file: {agentConfig.BenchClientListFile}");
}
if (agentConfig.VMHostFile != null)
{
Util.Log($"VM host output file: {agentConfig.VMHostFile}");
}
Util.Log($"auth file: {agentConfig.AuthFile}");
var credentials = SdkContext.AzureCredentialsFactory
.FromFile(agentConfig.AuthFile);
var azure = Azure
.Configure()
.WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic)
.Authenticate(credentials)
.WithDefaultSubscription();
var img = azure.VirtualMachineCustomImages.GetByResourceGroup(agentConfig.ImgResourceGroup, agentConfig.ImgName);
Util.Log($"Customized image id: {img.Id}");
var region = img.Region;
Util.Log($"target region: {region.Name}");
var VmSize = VirtualMachineSizeTypes.Parse(agentConfig.VmSize);
Util.Log($"VM size: {VmSize}");
if (agentConfig.SshPubKeyFile != null)
{
var sshPubKey = System.IO.File.ReadAllText(agentConfig.SshPubKeyFile);
Util.Log($"SSH public key: {sshPubKey}");
}
Util.Log($"Accelerated Network: {agentConfig.AcceleratedNetwork}");
}
// Ensure VMs for the LB
public IEnumerable <IVirtualMachine> EnsureVMs(
INetworks networks,
IComputeManager computeManager,
int count)
{
// Create a network for the VMs
INetwork network = networks.Define("net" + TestId)
.WithRegion(Region)
.WithNewResourceGroup(GroupName)
.WithAddressSpace("10.0.0.0/28")
.WithSubnet("subnet1", "10.0.0.0/29")
.WithSubnet("subnet2", "10.0.0.8/29")
.Create();
// Define an availability set for the VMs
var availabilitySetDefinition = computeManager.AvailabilitySets.Define("as" + TestId)
.WithRegion(Region)
.WithExistingResourceGroup(GroupName)
.WithSku(AvailabilitySetSkuTypes.Aligned);
// Create the requested number of VM definitions
string userName = "******" + TestId;
List <ICreatable <IVirtualMachine> > vmDefinitions = new List <ICreatable <IVirtualMachine> >();
for (int i = 0; i < count; i++)
{
string vmName = TestUtilities.GenerateName("vm");
var vm = computeManager.VirtualMachines.Define(vmName)
.WithRegion(Region)
.WithExistingResourceGroup(GroupName)
.WithExistingPrimaryNetwork(network)
.WithSubnet(network.Subnets.Values.First().Name)
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer14_04_Lts)
.WithRootUsername(userName)
.WithRootPassword("Abcdef.123456")
.WithNewAvailabilitySet(availabilitySetDefinition)
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"));
vmDefinitions.Add(vm);
}
var createdVMs = computeManager.VirtualMachines.Create(vmDefinitions.ToArray());
return(createdVMs);
}
public void CanCreateVirtualMachineWithManagedDiskInManagedAvailabilitySet()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var availSetName = SdkContext.RandomResourceName("av-", 15);
var uname = "juser";
var password = TestUtilities.GenerateName("Pa5$");
var vmName = "myvm6";
var resourceManager = TestHelper.CreateRollupClient();
var computeManager = TestHelper.CreateComputeManager();
var rgName = TestUtilities.GenerateName("rgfluentchash-");
try
{
var managedVM = computeManager.VirtualMachines
.Define(vmName)
.WithRegion(Location)
.WithNewResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithPopularLinuxImage(LinuxImage)
.WithRootUsername(uname)
.WithRootPassword(password)
.WithNewDataDisk(100)
.WithNewDataDisk(100, 1, CachingTypes.ReadOnly)
.WithNewDataDisk(100, 2, CachingTypes.ReadWrite, StorageAccountTypes.StandardLRS)
.WithNewAvailabilitySet(availSetName) // Default to managed availability set
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.WithOSDiskCaching(CachingTypes.ReadWrite)
.Create();
Assert.NotNull(managedVM.AvailabilitySetId);
var availabilitySet = computeManager.AvailabilitySets.GetById(managedVM.AvailabilitySetId);
Assert.True(availabilitySet.VirtualMachineIds.Count > 0);
Assert.Equal(availabilitySet.Sku, AvailabilitySetSkuTypes.Aligned);
}
finally
{
try
{
resourceManager.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
private IVirtualMachine PrepareGeneralizedVMWith2EmptyDataDisks(string rgName,
string vmName,
Region Location,
IComputeManager computeManager)
{
var uname = "javauser";
var password = TestUtilities.GenerateName("Pa5$");
KnownLinuxVirtualMachineImage linuxImage = KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts;
var publicIPDnsLabel = SdkContext.RandomResourceName("pip", 20);
var virtualMachine = computeManager.VirtualMachines
.Define(vmName)
.WithRegion(Location)
.WithNewResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithNewPrimaryPublicIPAddress(publicIPDnsLabel)
.WithPopularLinuxImage(linuxImage)
.WithRootUsername(uname)
.WithRootPassword(password)
.WithUnmanagedDisks()
.DefineUnmanagedDataDisk("disk-1")
.WithNewVhd(30)
.WithCaching(CachingTypes.ReadWrite)
.Attach()
.DefineUnmanagedDataDisk("disk-2")
.WithNewVhd(60)
.WithCaching(CachingTypes.ReadOnly)
.Attach()
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.WithNewStorageAccount(SdkContext.RandomResourceName("stg", 17))
.WithOSDiskCaching(CachingTypes.ReadWrite)
.Create();
//
TestHelper.DeprovisionAgentInLinuxVM(virtualMachine.GetPrimaryPublicIPAddress().Fqdn, 22, uname, password);
virtualMachine.Deallocate();
virtualMachine.Generalize();
return(virtualMachine);
}
public static void ConfigureLinuxWithPassword(
this VirtualMachine vm,
VirtualMachineSizeTypes vmSize,
string machineName,
string userName,
string password,
string linuxOffer = "UbuntuServer",
string publisher = "Canonical",
string sku = "18.04-LTS",
string version = "latest",
LinuxConfiguration configuration = null)
{
vm.OsProfile = new OSProfile
{
// TODO User name, password, SSH should have helpers
ComputerName = machineName,
AdminUsername = userName,
AdminPassword = password,
LinuxConfiguration = configuration,
};
vm.StorageProfile = new StorageProfile()
{
ImageReference = new ImageReference()
{
Offer = "UbuntuServer",
Publisher = "Canonical",
Sku = "18.04-LTS",
Version = "latest"
},
DataDisks = new List <DataDisk>()
};
vm.HardwareProfile = new HardwareProfile()
{
VmSize = VirtualMachineSizeTypes.StandardB1Ms
};
}
/// <summary>
/// Creates a Virtual Machine
/// </summary>
/// <param name="name">name of Virtual Machine</param>
/// <param name="resourceGroup">Name of Resource Group</param>
/// <param name="region">Region where Virtual Machine resides</param>
/// <param name="primaryNetwork">Primary Network</param>
/// <param name="primaryPublicIPAddress">Primary Public IP Address</param>
/// <param name="image">Image Type (Windows/Linux)</param>
/// <param name="adminUserName">Administrator Name</param>
/// <param name="adminUserPwd">Administrator Password</param>
/// <param name="vmSize">Size of the Virtual Machine</param>
/// <returns></returns>
public IVirtualMachine CreateWindowsVM(
string name,
string resourceGroup,
Region region,
string primaryNetwork,
string primaryPublicIPAddress,
KnownWindowsVirtualMachineImage image,
string adminUserName,
string adminUserPwd,
VirtualMachineSizeTypes vmSize
)
{
return(azure.VirtualMachines.Define(name)
.WithRegion(region)
.WithExistingResourceGroup(resourceGroup)
.WithNewPrimaryNetwork(primaryNetwork)
.WithPrimaryPrivateIPAddressDynamic()
.WithNewPrimaryPublicIPAddress(primaryPublicIPAddress)
.WithPopularWindowsImage(image)
.WithAdminUsername(adminUserName)
.WithAdminPassword(adminUserPwd)
.WithSize(vmSize)
.Create());
}
public void CanSetMSIOnNewVMWithMultipleRoleAssignments()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var groupName = TestUtilities.GenerateName("rgmsi");
var storageAccountName = TestUtilities.GenerateName("ja");
var region = Region.USEast2;
var vmName = "javavm";
IAzure azure = null;
try
{
azure = TestHelper.CreateRollupClient();
IStorageAccount storageAccount = azure.StorageAccounts
.Define(storageAccountName)
.WithRegion(region)
.WithNewResourceGroup(groupName)
.Create();
var resourceGroup = azure.ResourceGroups.GetByName(storageAccount.ResourceGroupName);
IVirtualMachine virtualMachine = azure.VirtualMachines
.Define(vmName)
.WithRegion(region)
.WithExistingResourceGroup(groupName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername("Foo12")
.WithRootPassword("abc!@#F0orL")
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.WithOSDiskCaching(CachingTypes.ReadWrite)
.WithSystemAssignedManagedServiceIdentity()
.WithSystemAssignedIdentityBasedAccessTo(resourceGroup.Id, BuiltInRole.Contributor)
.WithSystemAssignedIdentityBasedAccessTo(storageAccount.Id, BuiltInRole.Contributor)
.Create();
var authenticatedClient = TestHelper.CreateAuthenticatedClient();
// TODO: Renable the below code snippet: https://github.com/Azure/azure-libraries-for-net/issues/739
//
// Comment out since the below code need external tennat.
//
////
//IServicePrincipal servicePrincipal = authenticatedClient
// .ServicePrincipals
// .GetById(virtualMachineScaleSet.SystemAssignedManagedServiceIdentityPrincipalId);
//Assert.NotNull(servicePrincipal);
//Assert.NotNull(servicePrincipal.Inner);
// Ensure role assigned for resource group
//
var rgRoleAssignments = authenticatedClient.RoleAssignments.ListByScope(resourceGroup.Id);
Assert.NotNull(rgRoleAssignments);
bool found = false;
foreach (var roleAssignment in rgRoleAssignments)
{
if (roleAssignment.PrincipalId != null && roleAssignment.PrincipalId.Equals(virtualMachine.SystemAssignedManagedServiceIdentityPrincipalId, StringComparison.OrdinalIgnoreCase))
{
found = true;
break;
}
}
Assert.True(found, "Resource group should have a role assignment with virtual machine MSI principal");
// Ensure role assigned for storage account
//
var stgRoleAssignments = authenticatedClient.RoleAssignments.ListByScope(storageAccount.Id);
Assert.NotNull(stgRoleAssignments);
found = false;
foreach (var roleAssignment in stgRoleAssignments)
{
if (roleAssignment.PrincipalId != null && roleAssignment.PrincipalId.Equals(virtualMachine.SystemAssignedManagedServiceIdentityPrincipalId, StringComparison.OrdinalIgnoreCase))
{
found = true;
break;
}
}
Assert.True(found, "Storage account should have a role assignment with virtual machine MSI principal");
}
finally
{
try
{
if (azure != null)
{
azure.ResourceGroups.BeginDeleteByName(groupName);
}
}
catch { }
}
}
}
public void CanInstallUninstallCustomExtension()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
string rgName = TestUtilities.GenerateName("vmexttest");
string location = "eastus";
string vmName = "javavm";
string mySqlInstallScript = "https://raw.githubusercontent.com/Azure/azure-quickstart-templates/4397e808d07df60ff3cdfd1ae40999f0130eb1b3/mysql-standalone-server-ubuntu/scripts/install_mysql_server_5.6.sh";
string installCommand = "bash install_mysql_server_5.6.sh Abc.123x(";
List <string> fileUris = new List <string>()
{
mySqlInstallScript
};
var azure = TestHelper.CreateRollupClient();
// Create Linux VM with a custom extension to install MySQL
//
try
{
var vm = azure.VirtualMachines
.Define(vmName)
.WithRegion(location)
.WithNewResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer14_04_Lts)
.WithRootUsername("Foo12")
.WithRootPassword("BaR@12abc!")
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.DefineNewExtension("CustomScriptForLinux")
.WithPublisher("Microsoft.OSTCExtensions")
.WithType("CustomScriptForLinux")
.WithVersion("1.4")
.WithMinorVersionAutoUpgrade()
.WithPublicSetting("fileUris", fileUris)
.WithPublicSetting("commandToExecute", installCommand)
.Attach()
.Create();
Assert.True(vm.ListExtensions().Count > 0);
Assert.True(vm.ListExtensions().ContainsKey("CustomScriptForLinux"));
IVirtualMachineExtension customScriptExtension;
Assert.True(vm.ListExtensions().TryGetValue("CustomScriptForLinux", out customScriptExtension));
Assert.NotNull(customScriptExtension);
Assert.Equal("Microsoft.OSTCExtensions", customScriptExtension.PublisherName);
Assert.Equal("CustomScriptForLinux", customScriptExtension.TypeName);
Assert.True(customScriptExtension.AutoUpgradeMinorVersionEnabled);
// Ensure the public settings are accessible, the protected settings won't be returned from the service.
//
var publicSettings = customScriptExtension.PublicSettings;
Assert.NotNull(publicSettings);
Assert.Equal(2, publicSettings.Count);
Assert.True(publicSettings.ContainsKey("fileUris"));
Assert.True(publicSettings.ContainsKey("commandToExecute"));
string commandToExecute = (string)publicSettings["commandToExecute"];
Assert.NotNull(commandToExecute);
Assert.Equal(commandToExecute, installCommand, true);
// Remove the custom extension
//
vm.Update()
.WithoutExtension("CustomScriptForLinux")
.Apply();
Assert.True(vm.ListExtensions().Count() == 0);
}
finally
{
try
{
azure.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
public void CanUpdateExtensionPublicPrivateSettings()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
Region region = Region.USEast2;
string rgName = TestUtilities.GenerateName("javacsmrg");
string stgName = TestUtilities.GenerateName("stg");
string vmName = TestUtilities.GenerateName("extvm");
var azure = TestHelper.CreateRollupClient();
try
{
var storageAccount = azure.StorageAccounts
.Define(stgName)
.WithRegion(Region.USEast2)
.WithNewResourceGroup(rgName)
.Create();
/*** CREATE VIRTUAL MACHINE WITH AN EXTENSION **/
var keys = storageAccount.GetKeys();
Assert.NotNull(keys);
Assert.True(keys.Count() > 0);
var storageAccountKey = keys.First();
string uri = prepareCustomScriptStorageUri(storageAccount.Name, storageAccountKey.Value, "scripts");
List <string> fileUris = new List <string>();
fileUris.Add(uri);
string commandToExecute = "bash install_apache.sh";
var vm = azure.VirtualMachines
.Define(vmName)
.WithRegion(region)
.WithExistingResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer14_04_Lts)
.WithRootUsername("Foo12")
.WithRootPassword("BaR@12abc!")
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.DefineNewExtension("CustomScriptForLinux")
.WithPublisher("Microsoft.OSTCExtensions")
.WithType("CustomScriptForLinux")
.WithVersion("1.4")
.WithMinorVersionAutoUpgrade()
.WithPublicSetting("fileUris", fileUris)
.WithProtectedSetting("commandToExecute", commandToExecute)
.WithProtectedSetting("storageAccountName", storageAccount.Name)
.WithProtectedSetting("storageAccountKey", storageAccountKey.Value)
.Attach()
.Create();
Assert.True(vm.ListExtensions().Count > 0);
Assert.True(vm.ListExtensions().ContainsKey("CustomScriptForLinux"));
IVirtualMachineExtension customScriptExtension;
Assert.True(vm.ListExtensions().TryGetValue("CustomScriptForLinux", out customScriptExtension));
Assert.NotNull(customScriptExtension);
Assert.Equal("Microsoft.OSTCExtensions", customScriptExtension.PublisherName, true);
Assert.Equal("CustomScriptForLinux", customScriptExtension.TypeName, true);
Assert.True(customScriptExtension.AutoUpgradeMinorVersionEnabled);
// Special check for C# implementation, seems runtime changed the actual type
// of public settings from dictionary to Newtonsoft.Json.Linq.JObject.
// In future such changes needs to be catched before attemptting inner conversion
// hence the below special validation (not applicable for Java)
//
Assert.NotNull(customScriptExtension.Inner);
Assert.NotNull(customScriptExtension.Inner.Settings);
bool isJObject = customScriptExtension.Inner.Settings is JObject;
bool isDictionary = customScriptExtension.Inner.Settings is IDictionary <string, object>;
Assert.True(isJObject || isDictionary);
// Ensure the public settings are accessible, the protected settings won't be returned from the service.
//
var publicSettings = customScriptExtension.PublicSettings;
Assert.NotNull(publicSettings);
Assert.Equal(1, publicSettings.Count);
Assert.True(publicSettings.ContainsKey("fileUris"));
string fileUrisString = (publicSettings["fileUris"]).ToString();
if (HttpMockServer.Mode != HttpRecorderMode.Playback)
{
Assert.Contains(uri, fileUrisString);
}
/*** UPDATE THE EXTENSION WITH NEW PUBLIC AND PROTECTED SETTINGS **/
// Regenerate the storage account key
//
storageAccount.RegenerateKey(storageAccountKey.KeyName);
keys = storageAccount.GetKeys();
Assert.NotNull(keys);
Assert.True(keys.Count() > 0);
var updatedStorageAccountKey = keys.FirstOrDefault(key => key.KeyName.Equals(storageAccountKey.KeyName, StringComparison.OrdinalIgnoreCase));
Assert.NotNull(updatedStorageAccountKey);
Assert.NotEqual(updatedStorageAccountKey.Value, storageAccountKey.Value);
// Upload the script to a different container ("scripts2") in the same storage account
//
var uri2 = prepareCustomScriptStorageUri(storageAccount.Name, updatedStorageAccountKey.Value, "scripts2");
List <string> fileUris2 = new List <string>();
fileUris2.Add(uri2);
string commandToExecute2 = "bash install_apache.sh";
vm.Update()
.UpdateExtension("CustomScriptForLinux")
.WithPublicSetting("fileUris", fileUris2)
.WithProtectedSetting("commandToExecute", commandToExecute2)
.WithProtectedSetting("storageAccountName", storageAccount.Name)
.WithProtectedSetting("storageAccountKey", updatedStorageAccountKey.Value)
.Parent()
.Apply();
Assert.True(vm.ListExtensions().Count > 0);
Assert.True(vm.ListExtensions().ContainsKey("CustomScriptForLinux"));
IVirtualMachineExtension customScriptExtension2;
Assert.True(vm.ListExtensions().TryGetValue("CustomScriptForLinux", out customScriptExtension2));
Assert.NotNull(customScriptExtension2);
Assert.Equal("Microsoft.OSTCExtensions", customScriptExtension2.PublisherName, true);
Assert.Equal("CustomScriptForLinux", customScriptExtension2.TypeName, true);
Assert.True(customScriptExtension2.AutoUpgradeMinorVersionEnabled);
var publicSettings2 = customScriptExtension2.PublicSettings;
Assert.NotNull(publicSettings2);
Assert.Equal(1, publicSettings2.Count);
Assert.True(publicSettings2.ContainsKey("fileUris"));
string fileUris2String = (publicSettings2["fileUris"]).ToString();
if (HttpMockServer.Mode != HttpRecorderMode.Playback)
{
Assert.Contains(uri2, fileUris2String);
}
}
finally
{
try
{
azure.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
public void CanHandleExtensionReference()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
string rgName = TestUtilities.GenerateName("vmexttest");
string location = "eastus";
string vmName = "javavm";
var azure = TestHelper.CreateRollupClient();
// Create a Linux VM
//
try
{
var vm = azure.VirtualMachines
.Define(vmName)
.WithRegion(location)
.WithNewResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer14_04_Lts)
.WithRootUsername("Foo12")
.WithRootPassword("BaR@12abc!")
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.DefineNewExtension("VMAccessForLinux")
.WithPublisher("Microsoft.OSTCExtensions")
.WithType("VMAccessForLinux")
.WithVersion("1.4")
.WithProtectedSetting("username", "Foo12")
.WithProtectedSetting("password", "B12a6@12xyz!")
.WithProtectedSetting("reset_ssh", "true")
.Attach()
.Create();
Assert.True(vm.ListExtensions().Count() > 0);
// Get the created virtual machine via VM List not by VM GET
var virtualMachines = azure.VirtualMachines
.ListByResourceGroup(rgName);
IVirtualMachine vmWithExtensionReference = null;
foreach (var virtualMachine in virtualMachines)
{
if (virtualMachine.Name.Equals(vmName, StringComparison.OrdinalIgnoreCase))
{
vmWithExtensionReference = virtualMachine;
break;
}
}
// The VM retrieved from the list will contain extensions as reference (i.e. with only id)
Assert.NotNull(vmWithExtensionReference);
// Update the extension
var vmWithExtensionUpdated = vmWithExtensionReference.Update()
.UpdateExtension("VMAccessForLinux")
.WithProtectedSetting("username", "Foo12")
.WithProtectedSetting("password", "muy!234OR")
.WithProtectedSetting("reset_ssh", "true")
.Parent()
.Apply();
// Again getting VM with extension reference
virtualMachines = azure.VirtualMachines
.ListByResourceGroup(rgName);
vmWithExtensionReference = null;
foreach (var virtualMachine in virtualMachines)
{
vmWithExtensionReference = virtualMachine;
}
Assert.NotNull(vmWithExtensionReference);
IVirtualMachineExtension accessExtension = null;
foreach (var extension in vmWithExtensionReference.ListExtensions().Values)
{
if (extension.Name.Equals("VMAccessForLinux", StringComparison.OrdinalIgnoreCase))
{
accessExtension = extension;
break;
}
}
// Even though VM's inner contain just extension reference VirtualMachine::extensions()
// should resolve the reference and get full extension.
Assert.NotNull(accessExtension);
Assert.NotNull(accessExtension.PublisherName);
Assert.NotNull(accessExtension.TypeName);
Assert.NotNull(accessExtension.VersionName);
}
finally
{
try
{
azure.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
public void CanUpdateVirtualMachineByReimagingDisks()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var publicIPDnsLabel = SdkContext.RandomResourceName("pip", 20);
var uname = "juser";
var password = TestUtilities.GenerateName("Pa5$");
// Create with implicit + explicit empty disks, check default and override
//
var vmName1 = "myvm1";
var explicitlyCreatedEmptyDiskName1 = SdkContext.RandomResourceName(vmName1 + "_mdisk_", 25);
var explicitlyCreatedEmptyDiskName2 = SdkContext.RandomResourceName(vmName1 + "_mdisk_", 25);
var explicitlyCreatedEmptyDiskName3 = SdkContext.RandomResourceName(vmName1 + "_mdisk_", 25);
var resourceManager = TestHelper.CreateRollupClient();
var computeManager = TestHelper.CreateComputeManager();
var rgName = TestUtilities.GenerateName("rgfluentchash-");
try
{
var resourceGroup = resourceManager.ResourceGroups
.Define(rgName)
.WithRegion(Location)
.Create();
var creatableEmptyDisk1 = computeManager.Disks
.Define(explicitlyCreatedEmptyDiskName1)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithData()
.WithSizeInGB(1);
var creatableEmptyDisk2 = computeManager.Disks
.Define(explicitlyCreatedEmptyDiskName2)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithData()
.WithSizeInGB(1);
var creatableEmptyDisk3 = computeManager.Disks
.Define(explicitlyCreatedEmptyDiskName3)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithData()
.WithSizeInGB(1);
var virtualMachine1 = computeManager.VirtualMachines
.Define(vmName1)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithNewPrimaryPublicIPAddress(publicIPDnsLabel)
.WithPopularWindowsImage(KnownWindowsVirtualMachineImage.WindowsServer2008R2_SP1)
.WithAdminUsername(uname)
.WithAdminPassword(password)
// Start: Add bunch of empty managed disks
.WithNewDataDisk(1)
.WithNewDataDisk(1, 1, CachingTypes.ReadOnly)
.WithNewDataDisk(creatableEmptyDisk1)
.WithNewDataDisk(creatableEmptyDisk2, 2, CachingTypes.ReadOnly)
.WithDataDiskDefaultCachingType(CachingTypes.ReadOnly)
.WithDataDiskDefaultStorageAccountType(StorageAccountTypes.StandardLRS)
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.WithOSDiskCaching(CachingTypes.ReadOnly)
.WithEphemeralOSDisk(DiffDiskOptions.Local)
.Create();
virtualMachine1.Update()
.WithoutDataDisk(1)
.WithNewDataDisk(1, 6, CachingTypes.ReadOnly) // CreateOption: EMPTY
.Apply();
Assert.NotNull(virtualMachine1.DataDisks);
Assert.Equal(4, virtualMachine1.DataDisks.Count); // Removed one added another
Assert.True(virtualMachine1.DataDisks.ContainsKey(6));
Assert.False(virtualMachine1.DataDisks.ContainsKey(1));
virtualMachine1.Reimage();
virtualMachine1.Refresh();
Assert.NotNull(virtualMachine1.DataDisks);
Assert.Equal(4, virtualMachine1.DataDisks.Count); // Removed one added another
Assert.True(virtualMachine1.DataDisks.ContainsKey(6));
Assert.False(virtualMachine1.DataDisks.ContainsKey(1));
}
finally
{
try
{
resourceManager.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
public static void RunSample(IAzure azure)
{
string rgName = SdkContext.RandomResourceName("rgSTMS", 20);
string networkName = SdkContext.RandomResourceName("nw", 20);
string subnetName = "subnetA";
string storageAccountName = SdkContext.RandomResourceName("sa", 15);
string publicIpName = SdkContext.RandomResourceName("pip", 20);
string vmName = SdkContext.RandomResourceName("vm", 10);
try
{
// ============================================================
// Create a virtual network and a subnet with storage service subnet access enabled
Utilities.Log("Creating a Virtual network and subnet with storage service subnet access enabled:");
INetwork network = azure.Networks.Define(networkName)
.WithRegion(Region.USEast)
.WithNewResourceGroup(rgName)
.WithAddressSpace("10.0.0.0/28")
.DefineSubnet(subnetName)
.WithAddressPrefix("10.0.0.8/29")
.WithAccessFromService(ServiceEndpointType.MicrosoftStorage)
.Attach()
.Create();
Utilities.Log("Created a Virtual network with subnet:");
Utilities.PrintVirtualNetwork(network);
// ============================================================
// Create a storage account with access to it allowed only from a specific subnet
var subnetId = $"{network.Id}/subnets/{subnetName}";
Utilities.Log($"Creating a storage account with access allowed only from the subnet{subnetId}");
IStorageAccount storageAccount = azure.StorageAccounts.Define(storageAccountName)
.WithRegion(Region.USEast)
.WithExistingResourceGroup(rgName)
.WithAccessFromSelectedNetworks()
.WithAccessFromNetworkSubnet(subnetId)
.Create();
Utilities.Log("Created storage account:");
Utilities.PrintStorageAccount(storageAccount);
// ============================================================
// Create a public IP address
Utilities.Log("Creating a Public IP address");
IPublicIPAddress publicIPAddress = azure.PublicIPAddresses
.Define(publicIpName)
.WithRegion(Region.USEast)
.WithExistingResourceGroup(rgName)
.WithLeafDomainLabel(publicIpName)
.Create();
Utilities.Log("Created Public IP address:");
Utilities.PrintIPAddress(publicIPAddress);
// ============================================================
// Create a virtual machine and associate the public IP address
Utilities.Log("Creating a VM with the Public IP address");
IVirtualMachine linuxVM = azure.VirtualMachines
.Define(vmName)
.WithRegion(Region.USEast)
.WithExistingResourceGroup(rgName)
.WithNewPrimaryNetwork("10.1.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithExistingPrimaryPublicIPAddress(publicIPAddress)
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername(Utilities.CreateUsername())
.WithRootPassword(Utilities.CreatePassword())
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.Create();
Utilities.Log($"Created the VM: {linuxVM.Id}");
Utilities.PrintVirtualMachine(linuxVM);
publicIPAddress.Refresh(); // Refresh public IP resource to populate the assigned IPv4 address
// ============================================================
// Update the storage account so that it can also be accessed from the PublicIP address
Utilities.Log($"Updating storage account with access also allowed from publicIP{publicIPAddress.IPAddress}");
storageAccount.Update()
.WithAccessFromIpAddress(publicIPAddress.IPAddress)
.Apply();
Utilities.Log("Updated storage account:");
Utilities.PrintStorageAccount(storageAccount);
// ============================================================
// Update the storage account to restrict incoming traffic to HTTPS
Utilities.Log("Restricting access to storage account only via HTTPS");
storageAccount.Update()
.WithOnlyHttpsTraffic()
.Apply();
Utilities.Log("Updated the storage account:");
Utilities.PrintStorageAccount(storageAccount);
}
finally
{
if (azure.ResourceGroups.GetByName(rgName) != null)
{
Utilities.Log("Deleting Resource Group: " + rgName);
azure.ResourceGroups.DeleteByName(rgName);
Utilities.Log("Deleted Resource Group: " + rgName);
}
else
{
Utilities.Log("Did not create any resources in Azure. No clean up is necessary");
}
}
}
/**
* Azure Network sample for creating a simple Internet facing load balancer -
*
* Summary ...
*
* - This sample creates a simple Internet facing load balancer that receives network traffic on
* port 80 and sends load-balanced traffic to two virtual machines
*
* Details ...
*
* 1. Create two virtual machines for the backend...
* - in the same availability set
* - in the same virtual network
*
* Create an Internet facing load balancer with ...
* - A public IP address assigned to an implicitly created frontend
* - One backend address pool with the two virtual machines to receive HTTP network traffic from the load balancer
* - One load balancing rule for HTTP to map public ports on the load
* balancer to ports in the backend address pool
*
* Delete the load balancer
*/
public static void RunSample(IAzure azure)
{
string rgName = SdkContext.RandomResourceName("rg", 15);
string vnetName = SdkContext.RandomResourceName("vnet", 24);
Region region = Region.USEast;
string loadBalancerName = SdkContext.RandomResourceName("lb", 18);
string publicIpName = SdkContext.RandomResourceName("pip", 18);
string availSetName = SdkContext.RandomResourceName("av", 24);
string httpLoadBalancingRuleName = "httpRule";
string userName = Utilities.CreateUsername();
string sshKey = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCfSPC2K7LZcFKEO+/t3dzmQYtrJFZNxOsbVgOVKietqHyvmYGHEC0J2wPdAqQ/63g/hhAEFRoyehM+rbeDri4txB3YFfnOK58jqdkyXzupWqXzOrlKY4Wz9SKjjN765+dqUITjKRIaAip1Ri137szRg71WnrmdP3SphTRlCx1Bk2nXqWPsclbRDCiZeF8QOTi4JqbmJyK5+0UqhqYRduun8ylAwKKQJ1NJt85sYIHn9f1Rfr6Tq2zS0wZ7DHbZL+zB5rSlAr8QyUdg/GQD+cmSs6LvPJKL78d6hMGk84ARtFo4A79ovwX/Fj01znDQkU6nJildfkaolH2rWFG/qttD [email protected]";
try
{
//=============================================================
// Define a common availability set for the backend virtual machines
ICreatable <IAvailabilitySet> availabilitySetDefinition = azure.AvailabilitySets.Define(availSetName)
.WithRegion(region)
.WithNewResourceGroup(rgName)
.WithSku(AvailabilitySetSkuTypes.Aligned);
//=============================================================
// Define a common virtual network for the virtual machines
ICreatable <INetwork> networkDefinition = azure.Networks.Define(vnetName)
.WithRegion(region)
.WithNewResourceGroup(rgName)
.WithAddressSpace("10.0.0.0/28");
//=============================================================
// Create two virtual machines for the backend of the load balancer
Utilities.Log("Creating two virtual machines in the frontend subnet ...\n"
+ "and putting them in the shared availability set and virtual network.");
List <ICreatable <IVirtualMachine> > virtualMachineDefinitions = new List <ICreatable <IVirtualMachine> >();
for (int i = 0; i < 2; i++)
{
virtualMachineDefinitions.Add(
azure.VirtualMachines.Define(SdkContext.RandomResourceName("vm", 24))
.WithRegion(region)
.WithExistingResourceGroup(rgName)
.WithNewPrimaryNetwork(networkDefinition)
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername(userName)
.WithSsh(sshKey)
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.WithNewAvailabilitySet(availabilitySetDefinition));
}
Stopwatch stopwatch = Stopwatch.StartNew();
// Create and retrieve the VMs by the interface accepted by the load balancing rule
var virtualMachines = azure.VirtualMachines.Create(virtualMachineDefinitions);
stopwatch.Stop();
Utilities.Log("Created 2 Linux VMs: (took " + (stopwatch.ElapsedMilliseconds / 1000) + " seconds)\n");
// Print virtual machine details
foreach (var vm in virtualMachines)
{
Utilities.PrintVirtualMachine((IVirtualMachine)vm);
}
//=============================================================
// Create an Internet facing load balancer
// - implicitly creating a frontend with the public IP address definition provided for the load balancing rule
// - implicitly creating a backend and assigning the created virtual machines to it
// - creating a load balancing rule, mapping public ports on the load balancer to ports in the backend address pool
Utilities.Log(
"Creating a Internet facing load balancer with ...\n"
+ "- A frontend public IP address\n"
+ "- One backend address pool with the two virtual machines\n"
+ "- One load balancing rule for HTTP, mapping public ports on the load\n"
+ " balancer to ports in the backend address pool");
var loadBalancer = azure.LoadBalancers.Define(loadBalancerName)
.WithRegion(region)
.WithExistingResourceGroup(rgName)
// Add a load balancing rule sending traffic from an implicitly created frontend with the public IP address
// to an implicitly created backend with the two virtual machines
.DefineLoadBalancingRule(httpLoadBalancingRuleName)
.WithProtocol(TransportProtocol.Tcp)
.FromNewPublicIPAddress(publicIpName)
.FromFrontendPort(80)
.ToExistingVirtualMachines(new List <IHasNetworkInterfaces>(virtualMachines)) // Convert VMs to the expected interface
.Attach()
.Create();
// Print load balancer details
Utilities.Log("Created a load balancer");
Utilities.PrintLoadBalancer(loadBalancer);
//=============================================================
// Update a load balancer with 15 minute idle time for the load balancing rule
Utilities.Log("Updating the load balancer ...");
loadBalancer.Update()
.UpdateLoadBalancingRule(httpLoadBalancingRuleName)
.WithIdleTimeoutInMinutes(15)
.Parent()
.Apply();
Utilities.Log("Updated the load balancer with a TCP idle timeout to 15 minutes");
//=============================================================
// Show the load balancer info
Utilities.PrintLoadBalancer(loadBalancer);
//=============================================================
// Remove a load balancer
Utilities.Log("Deleting load balancer " + loadBalancerName
+ "(" + loadBalancer.Id + ")");
azure.LoadBalancers.DeleteById(loadBalancer.Id);
Utilities.Log("Deleted load balancer" + loadBalancerName);
}
finally
{
try
{
Utilities.Log("Starting the deletion of the resource group: " + rgName);
azure.ResourceGroups.BeginDeleteByName(rgName);
}
catch (NullReferenceException)
{
Utilities.Log("Did not create any resources in Azure. No clean up is necessary");
}
catch (Exception ex)
{
Utilities.Log(ex);
}
}
}
/**
* Azure Compute sample for managing virtual machines.
* - Create an un-managed virtual machine from PIR image with data disks
* - Create managed disks from specialized un-managed OS and Data disk of virtual machine
* - Create a virtual machine by attaching the managed disks
* - Get SAS Uri to the virtual machine's managed disks
*/
public static void RunSample(IAzure azure)
{
var linuxVmName1 = Utilities.CreateRandomName("VM1");
var linuxVmName2 = Utilities.CreateRandomName("VM2");
var managedOSDiskName = Utilities.CreateRandomName("ds-os-");
var managedDataDiskNamePrefix = Utilities.CreateRandomName("ds-data-");
var rgName = Utilities.CreateRandomName("rgCOMV");
var publicIpDnsLabel = Utilities.CreateRandomName("pip");
var storageAccountName = Utilities.CreateRandomName("stg");
var apacheInstallScript = "https://raw.githubusercontent.com/Azure/azure-libraries-for-net/master/Samples/Asset/install_apache.sh";
var apacheInstallCommand = "bash install_apache.sh";
var apacheInstallScriptUris = new List <string>();
apacheInstallScriptUris.Add(apacheInstallScript);
try
{
//=============================================================
// Create a Linux VM using an image from PIR (Platform Image Repository)
Utilities.Log("Creating a un-managed Linux VM");
var linuxVM = azure.VirtualMachines.Define(linuxVmName1)
.WithRegion(region)
.WithNewResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithNewPrimaryPublicIPAddress(publicIpDnsLabel)
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername(userName)
.WithRootPassword(password)
.WithUnmanagedDisks()
.DefineUnmanagedDataDisk("disk-1")
.WithNewVhd(50)
.WithLun(1)
.Attach()
.DefineUnmanagedDataDisk("disk-2")
.WithNewVhd(50)
.WithLun(2)
.Attach()
.DefineNewExtension("CustomScriptForLinux")
.WithPublisher("Microsoft.OSTCExtensions")
.WithType("CustomScriptForLinux")
.WithVersion("1.4")
.WithMinorVersionAutoUpgrade()
.WithPublicSetting("fileUris", apacheInstallScriptUris)
.WithPublicSetting("commandToExecute", apacheInstallCommand)
.Attach()
.WithNewStorageAccount(storageAccountName)
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.Create();
Utilities.Log("Created a Linux VM with un-managed OS and data disks: " + linuxVM.Id);
Utilities.PrintVirtualMachine(linuxVM);
// Gets the specialized OS and Data disk VHDs of the virtual machine
//
var specializedOSVhdUri = linuxVM.OSUnmanagedDiskVhdUri;
var dataVhdUris = new List <string>();
foreach (var dataDisk in linuxVM.UnmanagedDataDisks.Values)
{
dataVhdUris.Add(dataDisk.VhdUri);
}
//=============================================================
// Delete the virtual machine
Utilities.Log("Deleting VM: " + linuxVM.Id);
azure.VirtualMachines.DeleteById(linuxVM.Id);
Utilities.Log("Deleted the VM");
//=============================================================
// Create Managed disk from the specialized OS VHD
Utilities.Log($"Creating managed disk from the specialized OS VHD: {specializedOSVhdUri} ");
var osDisk = azure.Disks.Define(managedOSDiskName)
.WithRegion(region)
.WithExistingResourceGroup(rgName)
.WithLinuxFromVhd(specializedOSVhdUri)
.WithStorageAccountName(storageAccountName)
.WithSizeInGB(100)
.Create();
Utilities.Log("Created managed disk holding OS: " + osDisk.Id);
// Utilities.Print(osDisk); TODO
//=============================================================
// Create Managed disks from the Data VHDs
var dataDisks = new List <IDisk>();
var i = 0;
foreach (String dataVhdUri in dataVhdUris)
{
Utilities.Log($"Creating managed disk from the Data VHD: {dataVhdUri}");
var dataDisk = azure.Disks.Define(managedDataDiskNamePrefix + "-" + i)
.WithRegion(region)
.WithExistingResourceGroup(rgName)
.WithData()
.FromVhd(dataVhdUri)
.WithStorageAccountName(storageAccountName)
.WithSizeInGB(150)
.WithSku(DiskSkuTypes.StandardLRS)
.Create();
dataDisks.Add(dataDisk);
Utilities.Log("Created managed disk holding data: " + dataDisk.Id);
// Utilities.Print(dataDisk); TODO
i++;
}
//=============================================================
// Create a Linux VM by attaching the disks
Utilities.Log("Creating a Linux VM using specialized OS and data disks");
var linuxVM2 = azure.VirtualMachines.Define(linuxVmName2)
.WithRegion(region)
.WithExistingResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithSpecializedOSDisk(osDisk, OperatingSystemTypes.Linux)
.WithExistingDataDisk(dataDisks[0])
.WithExistingDataDisk(dataDisks[1], 1, CachingTypes.ReadWrite)
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.Create();
Utilities.PrintVirtualMachine(linuxVM2);
var dataDiskIds = new List <string>();
foreach (var disk in linuxVM2.DataDisks.Values)
{
dataDiskIds.Add(disk.Id);
}
//=============================================================
// Detach the data disks from the virtual machine
Utilities.Log("Updating VM by detaching the data disks");
linuxVM2.Update()
.WithoutDataDisk(0)
.WithoutDataDisk(1)
.Apply();
Utilities.PrintVirtualMachine(linuxVM2);
//=============================================================
// Get the readonly SAS URI to the data disks
Utilities.Log("Getting data disks SAS Uris");
foreach (String diskId in dataDiskIds)
{
var dataDisk = azure.Disks.GetById(diskId);
var dataDiskSasUri = dataDisk.GrantAccess(24 * 60);
Utilities.Log($"Data disk SAS Uri: {dataDiskSasUri}");
}
}
finally
{
try
{
Utilities.Log("Deleting Resource Group: " + rgName);
azure.ResourceGroups.DeleteByName(rgName);
Utilities.Log("Deleted Resource Group: " + rgName);
}
catch (NullReferenceException)
{
Utilities.Log("Did not create any resources in Azure. No clean up is necessary");
}
catch (Exception g)
{
Utilities.Log(g);
}
}
}
public void CanCreateVirtualMachineByAttachingManagedOsDisk()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var uname = "juser";
var password = TestUtilities.GenerateName("Pa5$");
var vmName = "myvm6";
var resourceManager = TestHelper.CreateRollupClient();
var computeManager = TestHelper.CreateComputeManager();
var rgName = TestUtilities.GenerateName("rgfluentchash-");
var storageAccountName = SdkContext.RandomResourceName("stg", 17);
try
{
// Creates a native virtual machine
//
var nativeVM = computeManager.VirtualMachines
.Define(vmName)
.WithRegion(Location)
.WithNewResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithLatestLinuxImage("Canonical", "UbuntuServer", "14.04.2-LTS")
.WithRootUsername(uname)
.WithRootPassword(password)
.WithUnmanagedDisks() /* UN-MANAGED OS and DATA DISKS */
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.WithNewStorageAccount(storageAccountName)
.WithOSDiskCaching(CachingTypes.ReadWrite)
.Create();
Assert.False(nativeVM.IsManagedDiskEnabled);
var osVhdUri = nativeVM.OSUnmanagedDiskVhdUri;
Assert.NotNull(osVhdUri);
computeManager.VirtualMachines.DeleteById(nativeVM.Id);
var diskName = SdkContext.RandomResourceName("dsk-", 15);
var osDisk = computeManager.Disks.Define(diskName)
.WithRegion(Location)
.WithExistingResourceGroup(rgName)
.WithLinuxFromVhd(osVhdUri)
.WithStorageAccountName(storageAccountName)
.Create();
// Creates a managed virtual machine
//
var managedVM = computeManager.VirtualMachines
.Define(vmName)
.WithRegion(Location)
.WithExistingResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithSpecializedOSDisk(osDisk, OperatingSystemTypes.Linux)
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.WithOSDiskCaching(CachingTypes.ReadWrite)
.Create();
Assert.True(managedVM.IsManagedDiskEnabled);
Assert.Equal(managedVM.OSDiskId, osDisk.Id, ignoreCase: true);
}
finally
{
try
{
resourceManager.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
/**
* Azure Compute sample for managing virtual machines -
* - Create a zonal virtual machine with implicitly zoned related resources (PublicIP, Disk)
* - Creates a zonal PublicIP address
* - Creates a zonal managed data disk
* - Create a zonal virtual machine and associate explicitly created zonal PublicIP and data disk.
*/
public static void RunSample(IAzure azure)
{
var region = Region.USEast2;
var rgName = Utilities.CreateRandomName("rgCOMV");
var vmName1 = Utilities.CreateRandomName("lVM1");
var vmName2 = Utilities.CreateRandomName("lVM2");
var pipName1 = Utilities.CreateRandomName("pip1");
var pipName2 = Utilities.CreateRandomName("pip2");
var diskName = Utilities.CreateRandomName("ds");
var userName = "******";
var password = "******";
try
{
//=============================================================
// Create a Linux VM in an availability zone
Utilities.Log("Creating a zonal VM with implicitly zoned related resources (PublicIP, Disk)");
var virtualMachine1 = azure.VirtualMachines
.Define(vmName1)
.WithRegion(region)
.WithNewResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithNewPrimaryPublicIPAddress(pipName1)
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername(userName)
.WithRootPassword(password)
// Optional
.WithAvailabilityZone(AvailabilityZoneId.Zone_1)
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
// Create VM
.Create();
Utilities.Log("Created a zonal virtual machine: " + virtualMachine1.Id);
//=============================================================
// Create a zonal PublicIP address
Utilities.Log("Creating a zonal public ip address");
var publicIPAddress = azure.PublicIPAddresses
.Define(pipName2)
.WithRegion(region)
.WithExistingResourceGroup(rgName)
// Optional
.WithAvailabilityZone(AvailabilityZoneId.Zone_1)
.WithStaticIP()
.WithSku(PublicIPSkuType.Standard)
// Create PIP
.Create();
Utilities.Log("Created a zonal public ip address: " + publicIPAddress.Id);
//=============================================================
// Create a zonal managed data disk
Utilities.Log("Creating a zonal data disk");
var dataDisk = azure.Disks
.Define(diskName)
.WithRegion(region)
.WithExistingResourceGroup(rgName)
.WithData()
.WithSizeInGB(100)
// Optional
.WithAvailabilityZone(AvailabilityZoneId.Zone_1)
// Create Disk
.Create();
Utilities.Log("Created a zoned managed data disk: " + dataDisk.Id);
//=============================================================
// Create a zonal virtual machine with zonal public ip and data disk
Utilities.Log("Creating a zonal VM with implicitly zoned related resources (PublicIP, Disk)");
var virtualMachine2 = azure.VirtualMachines
.Define(vmName2)
.WithRegion(region)
.WithNewResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithExistingPrimaryPublicIPAddress(publicIPAddress)
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername(userName)
.WithRootPassword(password)
// Optional
.WithAvailabilityZone(AvailabilityZoneId.Zone_1)
.WithExistingDataDisk(dataDisk)
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
// Create VM
.Create();
Utilities.Log("Created a zoned virtual machine: " + virtualMachine2.Id);
}
finally
{
try
{
Utilities.Log("Deleting Resource Group: " + rgName);
azure.ResourceGroups.DeleteByName(rgName);
Utilities.Log("Deleted Resource Group: " + rgName);
}
catch (NullReferenceException)
{
Utilities.Log("Did not create any resources in Azure. No clean up is necessary");
}
catch (Exception g)
{
Utilities.Log(g);
}
}
}
public void CanCreateFromCustomImageWithManagedDisk()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var userName = "******";
var password = TestUtilities.GenerateName("Pa5$");
var publicIPDnsLabel = SdkContext.RandomResourceName("pip", 10);
var customImageName = SdkContext.RandomResourceName("img", 10);
var vmssName = SdkContext.RandomResourceName("vmss", 10);
var resourceManager = TestHelper.CreateRollupClient();
var computeManager = TestHelper.CreateComputeManager();
var networkManager = TestHelper.CreateNetworkManager();
var rgName = TestUtilities.GenerateName("rgfluentchash-");
try
{
var resourceGroup = resourceManager.ResourceGroups
.Define(rgName)
.WithRegion(Location)
.Create();
var vm = computeManager.VirtualMachines.Define(SdkContext.RandomResourceName("vm", 10))
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithNewPrimaryPublicIPAddress(publicIPDnsLabel)
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername(userName)
.WithRootPassword(password)
.WithUnmanagedDisks()
.DefineUnmanagedDataDisk("disk-1")
.WithNewVhd(100)
.WithLun(1)
.Attach()
.DefineUnmanagedDataDisk("disk-2")
.WithNewVhd(50)
.WithLun(2)
.Attach()
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.Create();
Assert.NotNull(vm);
TestHelper.DeprovisionAgentInLinuxVM(vm.GetPrimaryPublicIPAddress().Fqdn, 22, userName, password);
vm.Deallocate();
vm.Generalize();
var virtualMachineCustomImage = computeManager.VirtualMachineCustomImages
.Define(customImageName)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.FromVirtualMachine(vm)
.Create();
Assert.NotNull(virtualMachineCustomImage);
var network = networkManager
.Networks
.Define(SdkContext.RandomResourceName("vmssvnet", 15))
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithAddressSpace("10.0.0.0/28")
.WithSubnet("subnet1", "10.0.0.0/28")
.Create();
var publicLoadBalancer = ScaleSet.CreateHttpLoadBalancers(resourceManager, resourceGroup, "1", Location);
var vmScaleSet = computeManager.VirtualMachineScaleSets
.Define(vmssName)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithSku(VirtualMachineScaleSetSkuTypes.StandardD5v2)
.WithExistingPrimaryNetworkSubnet(network, "subnet1")
.WithExistingPrimaryInternetFacingLoadBalancer(publicLoadBalancer)
.WithoutPrimaryInternalLoadBalancer()
.WithLinuxCustomImage(virtualMachineCustomImage.Id)
.WithRootUsername(userName)
.WithRootPassword(password)
.Create();
var virtualMachineScaleSetVMs = vmScaleSet.VirtualMachines;
var virtualMachines = virtualMachineScaleSetVMs.List();
Assert.Equal(virtualMachines.Count(), vmScaleSet.Capacity);
foreach (var vm1 in virtualMachines)
{
Assert.True(vm1.IsOSBasedOnCustomImage);
Assert.False(vm1.IsOSBasedOnPlatformImage);
Assert.False(vm1.IsOSBasedOnStoredImage);
Assert.True(vm1.IsManagedDiskEnabled);
Assert.NotNull(vm1.UnmanagedDataDisks);
Assert.Empty(vm1.UnmanagedDataDisks);
Assert.NotNull(vm1.DataDisks);
Assert.Equal(2, vm1.DataDisks.Count); // Disks from data disk image from custom image
Assert.True(vm1.DataDisks.ContainsKey(1));
var disk = vm1.DataDisks[1];
Assert.Equal(100, disk.Size);
Assert.True(vm1.DataDisks.ContainsKey(2));
disk = vm1.DataDisks[2];
Assert.Equal(50, disk.Size);
}
vmScaleSet.Deallocate();
// Updating and adding disk as part of VMSS Update seems consistency failing, CRP is aware of
// this, hence until it is fixed comment-out the test
//
// {
// "startTime": "2017-01-25T06:10:55.2243509+00:00",
// "endTime": "2017-01-25T06:11:07.8649525+00:00",
// "status": "Failed",
// "error": {
// "code": "InternalExecutionError",
// "message": "An internal execution error occurred."
// },
// "name": "6786df83-ed3f-4d7a-bf58-d295b96fef46"
// }
//
// vmScaleSet.Update()
// .WithDataDiskUpdated(1, 200) // update not supported
// .WithNewDataDisk(100)
// .Apply();
//
// vmScaleSet.Start();
//
// virtualMachineScaleSetVMs = vmScaleSet.VirtualMachines;
// virtualMachines = virtualMachineScaleSetVMs.List();
// foreach (VirtualMachineScaleSetVM vm1 in virtualMachines) {
// Assert.True(vm1.IsOSBasedOnCustomImage());
// Assert.False(vm1.IsOSBasedOnPlatformImage());
// Assert.False(vm1.IsOSBasedOnStoredImage());
// Assert.True(vm1.IsManagedDiskEnabled());
// Assert.NotNull(vm1.UnmanagedDataDisks());
// Assert.Equal(vm1.UnmanagedDataDisks().Size(), 0);
// Assert.NotNull(vm1.DataDisks());
// Assert.Equal(vm1.DataDisks().Size(), 3);
// Assert.True(vm1.DataDisks().ContainsKey(1));
// VirtualMachineDataDisk disk = vm1.DataDisks().Get(1);
// Assert.Equal(disk.Size(), 200);
// Assert.True(vm1.DataDisks().ContainsKey(2));
// disk = vm1.DataDisks().Get(2);
// Assert.Equal(disk.Size(), 50);
// Assert.True(vm1.DataDisks().ContainsKey(0));
// disk = vm1.DataDisks().Get(0);
// Assert.Equal(disk.Size(), 100);
// }
}
finally
{
try
{
resourceManager.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
public void CanCreateUpdateVirtualMachineWithEmptyManagedDataDisks()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var publicIPDnsLabel = SdkContext.RandomResourceName("pip", 20);
var uname = "juser";
var password = TestUtilities.GenerateName("Pa5$");
// Create with implicit + explicit empty disks, check default and override
//
var vmName1 = "myvm1";
var explicitlyCreatedEmptyDiskName1 = SdkContext.RandomResourceName(vmName1 + "_mdisk_", 25);
var explicitlyCreatedEmptyDiskName2 = SdkContext.RandomResourceName(vmName1 + "_mdisk_", 25);
var explicitlyCreatedEmptyDiskName3 = SdkContext.RandomResourceName(vmName1 + "_mdisk_", 25);
var resourceManager = TestHelper.CreateRollupClient();
var computeManager = TestHelper.CreateComputeManager();
var rgName = TestUtilities.GenerateName("rgfluentchash-");
try
{
var resourceGroup = resourceManager.ResourceGroups
.Define(rgName)
.WithRegion(Location)
.Create();
var creatableEmptyDisk1 = computeManager.Disks
.Define(explicitlyCreatedEmptyDiskName1)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithData()
.WithSizeInGB(150);
var creatableEmptyDisk2 = computeManager.Disks
.Define(explicitlyCreatedEmptyDiskName2)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithData()
.WithSizeInGB(150);
var creatableEmptyDisk3 = computeManager.Disks
.Define(explicitlyCreatedEmptyDiskName3)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithData()
.WithSizeInGB(150);
var virtualMachine = computeManager.VirtualMachines
.Define(vmName1)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithNewPrimaryPublicIPAddress(publicIPDnsLabel)
.WithPopularLinuxImage(LinuxImage)
.WithRootUsername(uname)
.WithRootPassword(password)
// Start: Add 5 empty managed disks
.WithNewDataDisk(100) // CreateOption: EMPTY
.WithNewDataDisk(100, 1, CachingTypes.ReadOnly) // CreateOption: EMPTY
.WithNewDataDisk(creatableEmptyDisk1) // CreateOption: ATTACH
.WithNewDataDisk(creatableEmptyDisk2, 2, CachingTypes.None) // CreateOption: ATTACH
.WithNewDataDisk(creatableEmptyDisk3, 3, CachingTypes.None) // CreateOption: ATTACH
// End : Add 5 empty managed disks
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.WithOSDiskCaching(CachingTypes.ReadWrite)
.Create();
Assert.True(virtualMachine.IsManagedDiskEnabled);
// There should not be any un-managed data disks
//
Assert.NotNull(virtualMachine.UnmanagedDataDisks);
Assert.Equal(0, virtualMachine.UnmanagedDataDisks.Count);
// Validate the managed data disks
//
var dataDisks = virtualMachine.DataDisks;
Assert.NotNull(dataDisks);
Assert.True(dataDisks.Count == 5);
Assert.True(dataDisks.ContainsKey(1));
var dataDiskLun1 = dataDisks[1];
Assert.NotNull(dataDiskLun1.Id);
Assert.Equal(CachingTypes.ReadOnly, dataDiskLun1.CachingType);
Assert.Equal(100, dataDiskLun1.Size);
Assert.True(dataDisks.ContainsKey(2));
var dataDiskLun2 = dataDisks[2];
Assert.NotNull(dataDiskLun2.Id);
Assert.Equal(CachingTypes.None, dataDiskLun2.CachingType);
Assert.Equal(150, dataDiskLun2.Size);
Assert.True(dataDisks.ContainsKey(3));
var dataDiskLun3 = dataDisks[3];
Assert.NotNull(dataDiskLun3.Id);
Assert.Equal(CachingTypes.None, dataDiskLun3.CachingType);
Assert.Equal(150, dataDiskLun3.Size);
// Validate the defaults assigned
//
foreach (var dataDisk in dataDisks.Values)
{
if (dataDisk.Lun != 1 && dataDisk.Lun != 2 && dataDisk.Lun != 3)
{
Assert.Equal(CachingTypes.ReadWrite, dataDisk.CachingType);
Assert.Equal(StorageAccountTypes.StandardLRS, dataDisk.StorageAccountType);
}
}
// Updating and adding disk as part of VM Update seems consistency failing, CRP is aware of
// this, hence until it is fixed comment-out the test
//
// {
// "startTime": "2017-01-26T05:48:59.9290573+00:00",
// "endTime": "2017-01-26T05:49:02.2884052+00:00",
// "status": "Failed",
// "error": {
// "code": "InternalExecutionError",
// "message": "An internal execution error occurred."
// },
// "name": "bc8072a7-38bb-445b-ae59-f16cf125342c"
// }
//
// virtualMachine.Deallocate();
//
// virtualMachine.Update()
// .WithDataDiskUpdated(1, 200)
// .WithDataDiskUpdated(2, 200, CachingTypes.ReadWrite)
// .WithNewDataDisk(60)
// .Apply();
//
// Assert.True(virtualMachine.IsManagedDiskEnabled());
// // There should not be any un-managed data disks
// //
// Assert.NotNull(virtualMachine.UnmanagedDataDisks());
// Assert.Equal(virtualMachine.UnmanagedDataDisks().Count, 0);
//
// // Validate the managed data disks
// //
// dataDisks = virtualMachine.DataDisks;
// Assert.NotNull(dataDisks);
// Assert.True(dataDisks.Count == 6);
// Assert.True(dataDisks.ContainsKey(1));
// dataDiskLun1 = dataDisks[1];
// Assert.NotNull(dataDiskLun1.Id);
// Assert.Equal(dataDiskLun1.CachingType(), CachingTypes.ReadOnly);
// Assert.Equal(dataDiskLun1.Count, 200); // 100 -> 200
//
// Assert.True(dataDisks.ContainsKey(2));
// dataDiskLun2 = dataDisks[2];
// Assert.NotNull(dataDiskLun2.Id);
// Assert.Equal(dataDiskLun2.CachingType(), CachingTypes.ReadWrite); // None -> ReadWrite
// Assert.Equal(dataDiskLun2.Count, 200); // 150 -> 200
//
// Assert.True(dataDisks.ContainsKey(3));
// dataDiskLun3 = dataDisks[3];
// Assert.NotNull(dataDiskLun3.Id);
// Assert.Equal(dataDiskLun3.CachingType(), CachingTypes.None);
// Assert.Equal(dataDiskLun3.Count, 150);
//
// // Ensure defaults of other disks are not affected
// foreach (VirtualMachineDataDisk dataDisk in dataDisks.Values()) {
// if (dataDisk.Lun != 1 && dataDisk.Lun != 3) {
// Assert.Equal(dataDisk.CachingType(), CachingTypes.ReadWrite);
// Assert.Equal(dataDisk.StorageAccountType(), StorageAccountTypes.STANDARD_LRS);
// }
// }
}
finally
{
try
{
resourceManager.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
/**
* Azure Compute sample for managing virtual machines -
* - Create an un-managed virtual machine from PIR image with data disks
* - Deallocate the virtual machine
* - Generalize the virtual machine
* - Create a virtual machine custom image from the virtual machine
* - Create a second managed virtual machine using the custom image
* - Create a third virtual machine using the custom image and configure the data disks
* - Deletes the custom image
* - Get SAS Uri to the virtual machine's managed disks.
*/
public static void RunSample(IAzure azure)
{
var linuxVmName1 = Utilities.CreateRandomName("VM1");
var linuxVmName2 = Utilities.CreateRandomName("VM2");
var linuxVmName3 = Utilities.CreateRandomName("VM3");
var customImageName = Utilities.CreateRandomName("img");
var rgName = Utilities.CreateRandomName("rgCOMV");
var publicIpDnsLabel = Utilities.CreateRandomName("pip");
var apacheInstallScript = "https://raw.githubusercontent.com/Azure/azure-libraries-for-net/master/Samples/Asset/install_apache.sh";
var apacheInstallCommand = "bash install_apache.sh";
var apacheInstallScriptUris = new List <string>();
apacheInstallScriptUris.Add(apacheInstallScript);
try
{
//=============================================================
// Create a Linux VM using a PIR image with un-managed OS and data disks and customize virtual
// machine using custom script extension
Utilities.Log("Creating a un-managed Linux VM");
var linuxVM = azure.VirtualMachines.Define(linuxVmName1)
.WithRegion(region)
.WithNewResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithNewPrimaryPublicIPAddress(publicIpDnsLabel)
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername(userName)
.WithRootPassword(password)
.WithUnmanagedDisks()
.DefineUnmanagedDataDisk("disk-1")
.WithNewVhd(100)
.WithLun(1)
.Attach()
.DefineUnmanagedDataDisk("disk-2")
.WithNewVhd(50)
.WithLun(2)
.Attach()
.DefineNewExtension("CustomScriptForLinux")
.WithPublisher("Microsoft.OSTCExtensions")
.WithType("CustomScriptForLinux")
.WithVersion("1.4")
.WithMinorVersionAutoUpgrade()
.WithPublicSetting("fileUris", apacheInstallScriptUris)
.WithPublicSetting("commandToExecute", apacheInstallCommand)
.Attach()
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.Create();
Utilities.Log("Created a Linux VM with un-managed OS and data disks: " + linuxVM.Id);
Utilities.PrintVirtualMachine(linuxVM);
// De-provision the virtual machine
Utilities.DeprovisionAgentInLinuxVM(linuxVM.GetPrimaryPublicIPAddress().Fqdn, 22, userName, password);
//=============================================================
// Deallocate the virtual machine
Utilities.Log("Deallocate VM: " + linuxVM.Id);
linuxVM.Deallocate();
Utilities.Log("De-allocated VM: " + linuxVM.Id + "; state = " + linuxVM.PowerState);
//=============================================================
// Generalize the virtual machine
Utilities.Log("Generalize VM: " + linuxVM.Id);
linuxVM.Generalize();
Utilities.Log("Generalized VM: " + linuxVM.Id);
//=============================================================
// Capture the virtual machine to get a 'Generalized image' with Apache
Utilities.Log("Capturing VM as custom image: " + linuxVM.Id);
var virtualMachineCustomImage = azure.VirtualMachineCustomImages
.Define(customImageName)
.WithRegion(region)
.WithExistingResourceGroup(rgName)
.FromVirtualMachine(linuxVM)
.Create();
Utilities.Log("Captured VM: " + linuxVM.Id);
Utilities.PrintVirtualMachineCustomImage(virtualMachineCustomImage);
//=============================================================
// Create a Linux VM using custom image
Utilities.Log("Creating a Linux VM using custom image - " + virtualMachineCustomImage.Id);
var linuxVM2 = azure.VirtualMachines.Define(linuxVmName2)
.WithRegion(region)
.WithExistingResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithLinuxCustomImage(virtualMachineCustomImage.Id)
.WithRootUsername(userName)
.WithRootPassword(password)
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.Create();
Utilities.PrintVirtualMachine(linuxVM2);
//=============================================================
// Create another Linux VM using custom image and configure the data disks from image and
// add another data disk
Utilities.Log("Creating another Linux VM with additional data disks using custom image - " + virtualMachineCustomImage.Id);
var linuxVM3 = azure.VirtualMachines.Define(linuxVmName3)
.WithRegion(region)
.WithExistingResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithLinuxCustomImage(virtualMachineCustomImage.Id)
.WithRootUsername(userName)
.WithRootPassword(password)
.WithNewDataDiskFromImage(1, 200, CachingTypes.ReadWrite) // TODO: Naming needs to be finalized
.WithNewDataDiskFromImage(2, 100, CachingTypes.ReadOnly)
.WithNewDataDisk(50)
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.Create();
Utilities.PrintVirtualMachine(linuxVM3);
// Getting the SAS URIs requires virtual machines to be de-allocated
// [Access not permitted because'disk' is currently attached to running VM]
//
Utilities.Log("De-allocating the virtual machine - " + linuxVM3.Id);
linuxVM3.Deallocate();
//=============================================================
// Get the readonly SAS URI to the OS and data disks
Utilities.Log("Getting OS and data disks SAS Uris");
// OS Disk SAS Uri
var osDisk = azure.Disks.GetById(linuxVM3.OSDiskId);
var osDiskSasUri = osDisk.GrantAccess(24 * 60);
Utilities.Log("OS disk SAS Uri: " + osDiskSasUri);
// Data disks SAS Uri
foreach (var disk in linuxVM3.DataDisks.Values)
{
var dataDisk = azure.Disks.GetById(disk.Id);
var dataDiskSasUri = dataDisk.GrantAccess(24 * 60);
Utilities.Log($"Data disk (lun: {disk.Lun}) SAS Uri: {dataDiskSasUri}");
}
//=============================================================
// Deleting the custom image
Utilities.Log("Deleting custom Image: " + virtualMachineCustomImage.Id);
azure.VirtualMachineCustomImages.DeleteById(virtualMachineCustomImage.Id);
Utilities.Log("Deleted custom image");
}
finally
{
try
{
Utilities.Log("Deleting Resource Group: " + rgName);
azure.ResourceGroups.DeleteByName(rgName);
Utilities.Log("Deleted Resource Group: " + rgName);
}
catch (NullReferenceException)
{
Utilities.Log("Did not create any resources in Azure. No clean up is necessary");
}
catch (Exception g)
{
Utilities.Log(g);
}
}
}
public void CanSetMSIOnExistingVMWithRoleAssignments()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var groupName = TestUtilities.GenerateName("rgmsi");
var storageAccountName = TestUtilities.GenerateName("ja");
var region = Region.USEast2;
var vmName = "javavm";
IAzure azure = null;
try
{
azure = TestHelper.CreateRollupClient();
IVirtualMachine virtualMachine = azure.VirtualMachines
.Define(vmName)
.WithRegion(region)
.WithNewResourceGroup(groupName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername("Foo12")
.WithRootPassword("abc!@#F0orL")
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.WithOSDiskCaching(CachingTypes.ReadWrite)
.WithSystemAssignedManagedServiceIdentity()
.Create();
Assert.NotNull(virtualMachine);
Assert.NotNull(virtualMachine.Inner);
Assert.True(virtualMachine.IsManagedServiceIdentityEnabled);
Assert.NotNull(virtualMachine.SystemAssignedManagedServiceIdentityPrincipalId);
Assert.NotNull(virtualMachine.SystemAssignedManagedServiceIdentityTenantId);
var authenticatedClient = TestHelper.CreateAuthenticatedClient();
// Ensure NO role assigned for resource group
//
var resourceGroup = azure.ResourceGroups.GetByName(virtualMachine.ResourceGroupName);
var rgRoleAssignments1 = authenticatedClient.RoleAssignments.ListByScope(resourceGroup.Id);
Assert.NotNull(rgRoleAssignments1);
bool found = false;
foreach (var roleAssignment in rgRoleAssignments1)
{
if (roleAssignment.PrincipalId != null && roleAssignment.PrincipalId.Equals(virtualMachine.SystemAssignedManagedServiceIdentityPrincipalId, StringComparison.OrdinalIgnoreCase))
{
found = true;
break;
}
}
Assert.False(found, "Resource group should not have a role assignment with virtual machine MSI principal");
virtualMachine.Update()
.WithSystemAssignedManagedServiceIdentity()
.WithSystemAssignedIdentityBasedAccessToCurrentResourceGroup(BuiltInRole.Contributor)
.Apply();
// Ensure role assigned for resource group
//
var roleAssignments2 = authenticatedClient.RoleAssignments.ListByScope(resourceGroup.Id);
Assert.NotNull(roleAssignments2);
foreach (var roleAssignment in roleAssignments2)
{
if (roleAssignment.PrincipalId != null && roleAssignment.PrincipalId.Equals(virtualMachine.SystemAssignedManagedServiceIdentityPrincipalId, StringComparison.OrdinalIgnoreCase))
{
found = true;
break;
}
}
Assert.True(found, "Resource group should have a role assignment with virtual machine MSI principal");
// Try adding the same role again, implementation should handle 'RoleAlreadyExists' error code and resume
//
virtualMachine.Update()
.WithSystemAssignedManagedServiceIdentity()
.WithSystemAssignedIdentityBasedAccessToCurrentResourceGroup(BuiltInRole.Contributor)
.Apply();
}
finally
{
try
{
if (azure != null)
{
azure.ResourceGroups.BeginDeleteByName(groupName);
}
}
catch { }
}
}
}
/**
* Azure Compute sample for managing virtual machines -
* - Create a virtual machine with Managed Service Identity enabled with access to resource group
* - Set custom script in the virtual machine that
* - install az cli in the virtual machine
* - uses az cli MSI credentials to create a storage account
* - Get storage account created through Managed Service Identity (MSI) credentials.
*/
public static void RunSample(IAzure azure)
{
var identityName = Utilities.CreateRandomName("idt");
var linuxVMName = Utilities.CreateRandomName("VM1");
var rgName = Utilities.CreateRandomName("rgCOMV");
var pipName = Utilities.CreateRandomName("pip1");
var userName = "******";
var password = "******";
var region = Region.USWestCentral;
var installScript = "https://raw.githubusercontent.com/Azure/azure-libraries-for-net/master/Samples/Asset/create_resources_with_msi.sh";
var installCommand = "bash create_resources_with_msi.sh {identityId} {stgName} {rgName} {location}";
List <String> fileUris = new List <String>();
fileUris.Add(installScript);
try
{
//=============================================================
// Create an identity with access to current resource group
var identity = azure.Identities
.Define(identityName)
.WithRegion(region)
.WithNewResourceGroup(rgName)
.WithAccessToCurrentResourceGroup(BuiltInRole.Contributor)
.Create();
//=============================================================
// Create a Linux VM with MSI enabled for contributor access to the current resource group
Utilities.Log("Creating a Linux VM with MSI enabled");
var virtualMachine = azure.VirtualMachines
.Define(linuxVMName)
.WithRegion(region)
.WithNewResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithNewPrimaryPublicIPAddress(pipName)
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername(userName)
.WithRootPassword(password)
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.WithOSDiskCaching(CachingTypes.ReadWrite)
.WithExistingUserAssignedManagedServiceIdentity(identity)
.Create();
Utilities.Log("Created virtual machine with MSI enabled");
Utilities.PrintVirtualMachine(virtualMachine);
// Prepare custom script to install az cli that uses MSI to create a storage account
//
var stgName = Utilities.CreateRandomName("st44");
installCommand = installCommand
.Replace("{identityId}", identity.Id)
.Replace("{stgName}", stgName)
.Replace("{rgName}", rgName)
.Replace("{location}", region.Name);
// Update the VM by installing custom script extension.
//
Utilities.Log("Installing custom script extension to configure az cli in the virtual machine");
Utilities.Log("az cli will use MSI credentials to create storage account");
virtualMachine.Update()
.DefineNewExtension("CustomScriptForLinux")
.WithPublisher("Microsoft.OSTCExtensions")
.WithType("CustomScriptForLinux")
.WithVersion("1.4")
.WithMinorVersionAutoUpgrade()
.WithPublicSetting("fileUris", fileUris)
.WithPublicSetting("commandToExecute", installCommand)
.Attach()
.Apply();
// Retrieve the storage account created by az cli using MSI credentials
//
var storageAccount = azure.StorageAccounts
.GetByResourceGroup(rgName, stgName);
Utilities.Log("Storage account created by az cli using MSI credential");
Utilities.PrintStorageAccount(storageAccount);
}
finally
{
try
{
Utilities.Log("Deleting Resource Group: " + rgName);
azure.ResourceGroups.BeginDeleteByName(rgName);
}
catch (NullReferenceException)
{
Utilities.Log("Did not create any resources in Azure. No clean up is necessary");
}
catch (Exception g)
{
Utilities.Log(g);
}
}
}
private IVirtualMachineCustomImage PrepareCustomImage(string rgName, Region region, IAzure azure)
{
string vmName = TestUtilities.GenerateName("muldvm");
string uname = "javauser";
string password = "******";
KnownLinuxVirtualMachineImage linuxImage = KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts;
string publicIpDnsLabel = TestUtilities.GenerateName("pip");
string storageName = TestUtilities.GenerateName("stg");
IVirtualMachine linuxVM = azure.VirtualMachines
.Define(vmName)
.WithRegion(region)
.WithExistingResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithNewPrimaryPublicIPAddress(publicIpDnsLabel)
.WithPopularLinuxImage(linuxImage)
.WithRootUsername(uname)
.WithRootPassword(password)
.WithUnmanagedDisks()
.DefineUnmanagedDataDisk("disk-1")
.WithNewVhd(30)
.WithCaching(CachingTypes.ReadWrite)
.Attach()
.DefineUnmanagedDataDisk("disk-2")
.WithNewVhd(60)
.WithCaching(CachingTypes.ReadOnly)
.Attach()
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.WithNewStorageAccount(storageName)
.WithOSDiskCaching(CachingTypes.ReadWrite)
.Create();
//
TestHelper.DeprovisionAgentInLinuxVM(linuxVM.GetPrimaryPublicIPAddress().Fqdn, 22, uname, password);
//
linuxVM.Deallocate();
linuxVM.Generalize();
//
string vhdBasedImageName = TestUtilities.GenerateName("img");
//
var creatableDisk = azure
.VirtualMachineCustomImages
.Define(vhdBasedImageName)
.WithRegion(region)
.WithExistingResourceGroup(rgName)
.WithLinuxFromVhd(linuxVM.OSUnmanagedDiskVhdUri, OperatingSystemStateTypes.Generalized)
.WithOSDiskCaching(linuxVM.OSDiskCachingType);
foreach (IVirtualMachineUnmanagedDataDisk disk in linuxVM.UnmanagedDataDisks.Values)
{
creatableDisk.DefineDataDiskImage()
.WithLun(disk.Lun)
.FromVhd(disk.VhdUri)
.WithDiskCaching(disk.CachingType)
.WithDiskSizeInGB(disk.Size + 10) // Resize each data disk image by +10GB
.Attach();
}
//
IVirtualMachineCustomImage customImage = creatableDisk.Create();
return(customImage);
}
