private static void InitVMIdentity(VirtualMachineInner vmInner, ResourceIdentityType identityType) { if (!identityType.Equals(ResourceIdentityType.UserAssigned) && !identityType.Equals(ResourceIdentityType.SystemAssigned)) { throw new ArgumentException("Invalid argument: " + identityType); } if (vmInner.Identity == null) { vmInner.Identity = new VirtualMachineIdentity(); } ResourceIdentityType?parsedIdentityType = vmInner.Identity.Type; if (parsedIdentityType == null || parsedIdentityType.Equals(ResourceIdentityType.None) || parsedIdentityType.Equals(identityType)) { vmInner.Identity.Type = identityType; } else { vmInner.Identity.Type = ResourceIdentityType.SystemAssignedUserAssigned; } if (vmInner.Identity.IdentityIds == null) { if (identityType.Equals(ResourceIdentityType.UserAssigned) || identityType.Equals(ResourceIdentityType.SystemAssignedUserAssigned)) { vmInner.Identity.IdentityIds = new List <string>(); } } }
/// <summary> /// Gets the MSI identity type. /// </summary> /// <param name="inner">the virtual machine inner</param> /// <returns>the MSI identity type</returns> internal static ResourceIdentityType?ManagedServiceIdentityType(VirtualMachineInner inner) { if (inner.Identity != null) { return(inner.Identity.Type); } return(null); }
/// <summary> /// Gets the MSI identity type. /// </summary> /// <param name="inner">the virtual machine inner</param> /// <returns>the MSI identity type</returns> internal static ResourceIdentityType?ManagedServiceIdentityType(VirtualMachineInner inner) { if (inner.Identity != null) { return(ResourceIdentityTypeEnumExtension.ParseResourceIdentityType(inner.Identity.Type)); } return(null); }
/// <summary> /// Specifies the definition of a not-yet-created user assigned identity to be associated with the virtual machine. /// </summary> /// <param name="virtualMachineInner">The virtual machine to set the identity.</param> /// <param name="vmTaskGroup">the task group of the virtual machine</param> /// <param name="creatableIdentity">the creatable user assigned identity</param> /// <returns>VirtualMachineMsiHelper.</returns> internal VirtualMachineMsiHelper WithNewUserAssignedManagedServiceIdentity(VirtualMachineInner virtualMachineInner, CreatorTaskGroup <IHasId> vmTaskGroup, ICreatable <IIdentity> creatableIdentity) { if (!this.userAssignedIdentityCreatableKeys.Contains(creatableIdentity.Key)) { InitVMIdentity(virtualMachineInner, ResourceIdentityType.UserAssigned); this.userAssignedIdentityCreatableKeys.Add(creatableIdentity.Key); ((creatableIdentity as IResourceCreator <IHasId>).CreatorTaskGroup).Merge(vmTaskGroup); } return(this); }
/// <summary> /// Retrieve the virtual machine. /// If the virtual machine does not exists then an error observable will be returned. /// </summary> /// <return>The retrieved virtual machine.</return> private async Task <VirtualMachineInner> RetrieveVirtualMachineAsync(CancellationToken cancellationToken = default(CancellationToken)) { virtualMachine = await this.computeManager.Inner.VirtualMachines.GetAsync(rgName, vmName, InstanceViewTypes.InstanceView, cancellationToken); if (virtualMachine == null) { throw new Exception($"VM with name '{vmName}' not found (resource group '{rgName}')"); } return(virtualMachine); }
/// <summary> /// Set user assigned identity ids to the given virtual machine inner model /// </summary> /// <param name="virtualMachineInner">the virtual machine inner model</param> /// <param name="vmTaskGroup">the virtual machine task group</param> internal void HandleUserAssignedIdentities(VirtualMachineInner virtualMachineInner, CreatorTaskGroup <IHasId> vmTaskGroup) { try { if (virtualMachineInner.Identity == null || virtualMachineInner.Identity.Type == null) { return; } var parsedIdentityType = virtualMachineInner.Identity.Type; if (parsedIdentityType.Equals(ResourceIdentityType.None) || parsedIdentityType.Equals(ResourceIdentityType.SystemAssigned)) { return; } foreach (var key in this.userAssignedIdentityCreatableKeys) { var identity = (IIdentity)vmTaskGroup.CreatedResource(key); if (!this.userAssignedIdentityIdsToAssociate.Contains(identity.Id)) { this.userAssignedIdentityIdsToAssociate.Add(identity.Id); } } if (virtualMachineInner.Identity.IdentityIds == null) { virtualMachineInner.Identity.IdentityIds = new List <string>(); } foreach (var identityId in this.userAssignedIdentityIdsToAssociate) { if (!virtualMachineInner.Identity.IdentityIds.Contains(identityId)) { virtualMachineInner.Identity.IdentityIds.Add(identityId); } } foreach (var identityId in this.userAssignedIdentityIdsToRemove) { if (virtualMachineInner.Identity.IdentityIds.Contains(identityId)) { virtualMachineInner.Identity.IdentityIds.Remove(identityId); } } if (virtualMachineInner.Identity.IdentityIds.Any()) { this.installExtensionIfNotInstalled = true; } } finally { this.userAssignedIdentityCreatableKeys.Clear(); this.userAssignedIdentityIdsToAssociate.Clear(); this.userAssignedIdentityIdsToRemove.Clear(); } }
/// <summary> /// Specifies that Managed Service Identity property needs to be set in the virtual machine. /// The access token will be available in the virtual machine at given port. /// </summary> /// <param name="port">The port in the virtual machine to get the access token from.</param> /// <param name="virtualMachineInner">The virtual machine to set the identity.</param> /// <param name="virtualMachineInner">The virtual machine to set the identity.</param> /// <return>VirtualMachineMsiHelper.</return> ///GENMHASH:4189D61DE8E151C0FB589513AA0D4612:40AA004E3EDDABF6FA387290F36BF4D4 internal VirtualMachineMsiHelper WithManagedServiceIdentity(int?port, VirtualMachineInner virtualMachineInner) { this.requireSetup = true; this.tokenPort = port; if (virtualMachineInner.Identity == null) { virtualMachineInner.Identity = new VirtualMachineIdentity(); } if (virtualMachineInner.Identity.Type == null) { virtualMachineInner.Identity.Type = ResourceIdentityType.SystemAssigned; } return(this); }
/// <summary> /// Shuts down the virtual machine and releases the compute resources. /// This method will not wait for the deallocation to happen. /// </summary> /// <param name="resourceGroup"></param> /// <param name="vm"></param> /// <param name="cancellationToken"></param> /// <returns></returns> public async Task BeginDeallocateVMAsync( IResourceGroup resourceGroup, VirtualMachineInner vm, CancellationToken cancellationToken = default ) { await _computeManagementClient .VirtualMachines .BeginDeallocateAsync( resourceGroup.Name, vm.Name, cancellationToken : cancellationToken ); }
public async Task <Microsoft.Azure.Management.Compute.Fluent.IDiskVolumeEncryptionMonitor> RefreshAsync(CancellationToken cancellationToken = default(CancellationToken)) { this.virtualMachine = await RetrieveVirtualMachineAsync(cancellationToken); if (virtualMachine.InstanceView != null && virtualMachine.InstanceView.Extensions != null) { foreach (var extension in virtualMachine.InstanceView.Extensions) { if (extension.Type != null && extension.Type.ToLower().StartsWith(EncryptionExtensionIdentifier.GetPublisherName().ToLower()) && extension.Name != null && EncryptionExtensionIdentifier.IsEncryptionTypeName(extension.Name, this.OSType())) { this.extensionInstanceView = extension; break; } } } return(this); }
/// <summary> /// Checks system assigned identity is enabled for the virtual machine. /// </summary> /// <param name="virtualMachine">the virtual machine</param> /// <returns>true if system assigned MSI is enabled, false otherwise</returns> private static bool IsSystemAssignedMSIEnabled(IVirtualMachine virtualMachine) { VirtualMachineInner VMInner = virtualMachine.Inner; if (VMInner.Identity == null) { return(false); } ResourceIdentityType?parsedIdentityType = VMInner.Identity.Type; if (parsedIdentityType == null || parsedIdentityType.Equals(ResourceIdentityType.None)) { return(false); } else { return(parsedIdentityType.Equals(ResourceIdentityType.SystemAssigned) || parsedIdentityType.Equals(ResourceIdentityType.SystemAssignedUserAssigned)); } }
///GENMHASH:5A2D79502EDA81E37A36694062AEDC65:061A846F0F7CA8B3F2DF8CA79A8D8B5A public async Task <Microsoft.Azure.Management.Compute.Fluent.IDiskVolumeEncryptionMonitor> RefreshAsync(CancellationToken cancellationToken = default(CancellationToken)) { // Refreshes the cached Windows virtual machine and installed encryption extension // var virtualMachine = await RetrieveVirtualMachineAsync(cancellationToken); this.virtualMachine = virtualMachine; if (virtualMachine.Resources != null) { foreach (var extension in virtualMachine.Resources) { if (EncryptionExtensionIdentifier.IsEncryptionPublisherName(extension.Publisher) && EncryptionExtensionIdentifier.IsEncryptionTypeName(extension.VirtualMachineExtensionType, OperatingSystemTypes.Windows)) { this.encryptionExtension = extension; break; } } } return(this); }
///GENMHASH:5A2D79502EDA81E37A36694062AEDC65:061A846F0F7CA8B3F2DF8CA79A8D8B5A public async Task <Microsoft.Azure.Management.Compute.Fluent.IDiskVolumeEncryptionMonitor> RefreshAsync(CancellationToken cancellationToken = default(CancellationToken)) { // Refreshes the cached Windows virtual machine and installed encryption extension // var virtualMachine = await RetrieveVirtualMachineAsync(cancellationToken); this.virtualMachine = virtualMachine; if (virtualMachine.Resources != null) { foreach (var extension in virtualMachine.Resources) { if (extension.Publisher.Equals("Microsoft.Azure.Security", StringComparison.OrdinalIgnoreCase) && extension.VirtualMachineExtensionType.Equals("AzureDiskEncryption", StringComparison.OrdinalIgnoreCase)) { this.encryptionExtension = extension; break; } } } return(this); }
public String GetPublicIpAdresss(string subId, string resourceGroup, string vmName) { foreach (IVirtualMachine virtualmachine in azure.VirtualMachines.List()) { Console.WriteLine("Addresss"); Console.WriteLine(virtualmachine.GetPrimaryPublicIPAddress().IPAddress); Console.WriteLine("Name"); Console.WriteLine(virtualmachine.Name); Console.WriteLine("ResourceGroupName"); Console.WriteLine(virtualmachine.ResourceGroupName); if (virtualmachine.ResourceGroupName.ToLower().Equals(resourceGroup.ToLower()) && virtualmachine.Name.ToLower().Equals(vmName.ToLower())) { return(virtualmachine.GetPrimaryPublicIPAddress().IPAddress); } } // var ipadress = azure.VirtualMachines.GetById(vmName).GetPrimaryPublicIPAddress().IPAddress; //Console.WriteLine("Addresss"); //Console.WriteLine(ipadress); // Console.ReadLine(); var credentials = SdkContext.AzureCredentialsFactory.FromServicePrincipal(clientId , clientsecrett, tenantId , AzureEnvironment.AzureGlobalCloud); var client = new ComputeManagementClient(credentials); client.SubscriptionId = subId; VirtualMachineInner vm = VirtualMachinesOperationsExtensions.GetAsync(client.VirtualMachines, resourceGroup, vmName).Result; var networkName = vm.NetworkProfile.NetworkInterfaces[0].Id.Split('/').Last(); var clientNetwork = new NetworkManagementClient(credentials); clientNetwork.SubscriptionId = subId; var network = NetworkInterfacesOperationsExtensions.GetAsync(clientNetwork.NetworkInterfaces, resourceGroup, vmName).Result; string ip = network.IpConfigurations[0].PrivateIPAddress; return(ip); }
/// <summary> /// Retrieve the encryption extension from the virtual machine and then retrieve it again with instance view expanded. /// If the virtual machine does not exists then an error observable will be returned, if the extension could not be /// located then an empty observable will be returned. /// </summary> /// <return>The retrieved extension.</return> ///GENMHASH:F5645D5F0FF252C17769B3B4778AD204:9A94E8179A8202B9101EC72C66DB254C private async Task <Models.VirtualMachineExtensionInner> RetrieveEncryptExtensionWithInstanceViewFromVMAsync(CancellationToken cancellationToken = default(CancellationToken)) { VirtualMachineInner virtualMachine = await this.computeManager .Inner .VirtualMachines .GetAsync(rgName, vmName, cancellationToken : cancellationToken); if (virtualMachine == null) { new Exception($"VM with name '{vmName}' not found (resource group '{rgName}')"); } if (virtualMachine.Resources != null) { foreach (var extension in virtualMachine.Resources) { if (extension.Publisher.Equals("Microsoft.Azure.Security", StringComparison.OrdinalIgnoreCase) && extension.VirtualMachineExtensionType.Equals("AzureDiskEncryptionForLinux", StringComparison.OrdinalIgnoreCase)) { return(await RetrieveExtensionWithInstanceViewAsync(extension, cancellationToken)); } } } return(await Task.FromResult <Models.VirtualMachineExtensionInner>(null)); }
public async Task <Microsoft.Azure.Management.Compute.Fluent.IDiskVolumeEncryptionMonitor> RefreshAsync(CancellationToken cancellationToken = default(CancellationToken)) { this.virtualMachine = await RetrieveVirtualMachineAsync(cancellationToken); return(this); }
/// <summary> /// Specifies that System Assigned Managed Service Identity needs to be enabled in the virtual machine. /// </summary> /// <param name="port">The port in the virtual machine to get the access token from.</param> /// <param name="virtualMachineInner">The virtual machine to set the identity.</param> /// <return>VirtualMachineMsiHelper.</return> internal VirtualMachineMsiHelper WithSystemAssignedManagedServiceIdentity(int?port, VirtualMachineInner virtualMachineInner) { this.installExtensionIfNotInstalled = true; this.tokenPort = port; InitVMIdentity(virtualMachineInner, ResourceIdentityType.SystemAssigned); return(this); }
/// <summary> /// Specifies that System Assigned Managed Service Identity needs to be enabled in the virtual machine. /// </summary> /// <param name="virtualMachineInner">The virtual machine to set the identity.</param> /// <return>VirtualMachineMsiHelper.</return> internal VirtualMachineMsiHelper WithSystemAssignedManagedServiceIdentity(VirtualMachineInner virtualMachineInner) { return(WithSystemAssignedManagedServiceIdentity(null, virtualMachineInner)); }
/// <summary> /// Specifies an existing user assigned identity to be associated with the virtual machine. /// </summary> /// <param name="identity">an existing user assigned identity</param> /// <returns>VirtualMachineMsiHelper.</returns> internal VirtualMachineMsiHelper WithExistingUserAssignedManagedServiceIdentity(VirtualMachineInner virtualMachineInner, IIdentity identity) { if (!this.userAssignedIdentityIdsToAssociate.Contains(identity.Id)) { InitVMIdentity(virtualMachineInner, ResourceIdentityType.UserAssigned); this.userAssignedIdentityIdsToAssociate.Add(identity.Id); } return(this); }
/// <summary> /// The operation to create or update a virtual machine. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='resourceGroupName'> /// The name of the resource group. /// </param> /// <param name='vmName'> /// The name of the virtual machine. /// </param> /// <param name='parameters'> /// Parameters supplied to the Create Virtual Machine operation. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <VirtualMachineInner> CreateOrUpdateAsync(this IVirtualMachinesOperations operations, string resourceGroupName, string vmName, VirtualMachineInner parameters, CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, vmName, parameters, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }