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); }