Example #1
0
        /// <summary>
        /// Creates a virtual machine in Azure.
        /// Creates all the required resources before creating VM.
        /// </summary>
        /// <param name="subscriptionId">Subscription Id</param>
        /// <param name="credentialName">Internet name/address used to identify entry in Credential Manager</param>
        /// <param name="appId">appid that is registered for this application in Azure Active Directory (AAD)</param>
        /// <param name="customerTenantId">Id or Domain of the customer Azure tenant</param>
        private static void CreateAzureVirtualMachine(string appId, string credentialName, string customerTenantId, string subscriptionId)
        {
            // Get Azure Authentication Token
            string azureToken = Reseller.GetAzureAuthTokenForCustomerTenant(appId, credentialName, customerTenantId);
            // Correlation Id to be used for this scenaario
            var correlationId = Guid.NewGuid().ToString();

            var resourceGroupName = Guid.NewGuid().ToString();

            // Appending suffix to resource group name to build names of other resources

            // Storage account names must be between 3 and 24 characters in length and use numbers and lower-case letters only.
            // So removing hyphen and truncating.
            var storageAccountName = String.Format("{0}sa", resourceGroupName.Replace("-", "").Remove(20));

            var networkSecurityGroupName = String.Format("{0}_nsg", resourceGroupName);
            var networkSecurityGroupId   =
                String.Format(
                    "/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.Network/networkSecurityGroups/{2}",
                    subscriptionId, resourceGroupName, networkSecurityGroupName);

            var virtualNetworkName = String.Format("{0}_vn", resourceGroupName);
            var subnetName         = String.Format("{0}_sn", resourceGroupName);
            var subNetId           =
                String.Format(
                    "/subscriptions/{0}/resourceGroups/{1}/providers/microsoft.network/virtualNetworks/{2}/subnets/{3}",
                    subscriptionId, resourceGroupName, virtualNetworkName, subnetName);

            var publicIpName = String.Format("{0}_pip", resourceGroupName);
            var publicIpId   =
                String.Format(
                    "/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.Network/publicIPAddresses/{2}",
                    subscriptionId, resourceGroupName, publicIpName);

            var networkInterfaceName = String.Format("{0}_nic", resourceGroupName);
            var networkInterfaceId   =
                String.Format(
                    "/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.Network/networkInterfaces/{2}",
                    subscriptionId, resourceGroupName, networkInterfaceName);

            var ipName            = String.Format("{0}_ip", resourceGroupName);
            var vitualMachineName = String.Format("{0}_vm", resourceGroupName);

            // Waiting Time (in seconds) For Resource to be Provisioned
            var retryAfter = 5;
            // Retry attempts for resource provisioning errors
            var retryAttempts = 5;
            var attempts      = 0;

            // The following resources are to be created in order before creating a virtual machine.

            // #1 Create Resource Group
            do
            {
                var createResourceGroupResponse = AzureResourceManager.CreateResourceGroup(subscriptionId, resourceGroupName,
                                                                                           azureToken, correlationId);
                if (createResourceGroupResponse == null)
                {
                    attempts++;
                }
                else
                {
                    attempts = retryAttempts + 1;

                    // Waiting for the resource group to be created, if the request is just Accepted and the creation is still pending.
                    if ((int)(createResourceGroupResponse.StatusCode) == (int)HttpStatusCode.Accepted)
                    {
                        AzureResourceManager.WaitForResourceGroupProvisioning(subscriptionId, resourceGroupName, retryAfter,
                                                                              azureToken, correlationId);
                    }
                }
            } while (attempts < retryAttempts);

            // #2 Create Storage Account
            // Register the subscription with Storage Resource Provider, for creating Storage Account
            // Storage Resource Provider
            const string storageProviderName = "Microsoft.Storage";

            AzureResourceManager.RegisterProvider(subscriptionId, storageProviderName, azureToken, correlationId);

            attempts = 0;
            do
            {
                var storageAccountResponse = AzureResourceManager.CreateStorageAccount(subscriptionId, resourceGroupName,
                                                                                       storageAccountName, azureToken, correlationId);
                if (storageAccountResponse == null)
                {
                    attempts++;
                }
                else
                {
                    attempts = retryAttempts + 1;
                    // Waiting for the storage account to be created, if the request is just Accepted and the creation is still pending.
                    if ((int)(storageAccountResponse.StatusCode) == (int)HttpStatusCode.Accepted)
                    {
                        var location = storageAccountResponse.Headers.Get("Location");
                        retryAfter = Int32.Parse(storageAccountResponse.Headers.Get("Retry-After"));
                        AzureResourceManager.WaitForStorageAccountProvisioning(location, resourceGroupName, retryAfter,
                                                                               azureToken, correlationId);
                    }
                }
            } while (attempts < retryAttempts);

            // Register the subscription with Network Resource Provider for creating Network Resources - Netowrk Securtiy Group, Virtual Network, Subnet, Public IP and Network Interface
            // Network Resource Provider
            const string networkProviderName = "Microsoft.Network";

            AzureResourceManager.RegisterProvider(subscriptionId, networkProviderName, azureToken, correlationId);

            // #3 Create Network Security Group
            attempts = 0;
            do
            {
                var networkSecurityGroupResponse = AzureResourceManager.CreateNetworkSecurityGroup(subscriptionId,
                                                                                                   resourceGroupName, networkSecurityGroupName, azureToken, correlationId);
                if (networkSecurityGroupResponse == null)
                {
                    attempts++;
                }
                else
                {
                    attempts = retryAttempts + 1;
                    // Waiting for the network security group to be created, if the request is just Accepted and the creation is still pending.
                    if ((int)(networkSecurityGroupResponse.StatusCode) == (int)HttpStatusCode.Accepted)
                    {
                        AzureResourceManager.WaitForNetworkSecurityGroupProvisioning(subscriptionId, resourceGroupName,
                                                                                     networkSecurityGroupName, retryAfter, azureToken, correlationId);
                    }
                }
            } while (attempts < retryAttempts);


            // #4 Create Virtual Network
            attempts = 0;
            do
            {
                var virtualNetworkResponse = AzureResourceManager.CreateVirtualNetwork(subscriptionId, resourceGroupName,
                                                                                       virtualNetworkName, azureToken, correlationId);
                if (virtualNetworkResponse == null)
                {
                    attempts++;
                }
                else
                {
                    attempts = retryAttempts + 1;
                    // Waiting for the virtual network to be created, if the request is just Accepted and the creation is still pending.
                    if ((int)(virtualNetworkResponse.StatusCode) == (int)HttpStatusCode.Accepted)
                    {
                        AzureResourceManager.WaitForVirtualNetworkProvisioning(subscriptionId, resourceGroupName,
                                                                               virtualNetworkName, retryAfter, azureToken, correlationId);
                    }
                }
            } while (attempts < retryAttempts);

            // #5 Create Subnet
            attempts = 0;
            do
            {
                var subNetResponse = AzureResourceManager.CreateSubNet(subscriptionId, resourceGroupName, virtualNetworkName,
                                                                       networkSecurityGroupId, subnetName, azureToken, correlationId);
                if (subNetResponse == null)
                {
                    attempts++;
                }
                else
                {
                    attempts = retryAttempts + 1;
                    // Waiting for the subnet to be created, if the request is just Accepted and the creation is still pending.
                    if ((int)(subNetResponse.StatusCode) == (int)HttpStatusCode.Accepted)
                    {
                        AzureResourceManager.WaitForSubNetProvisioning(subscriptionId, resourceGroupName, virtualNetworkName,
                                                                       subnetName, retryAfter, azureToken, correlationId);
                    }
                }
            } while (attempts < retryAttempts);

            // #6 Create Public IP Address
            attempts = 0;
            do
            {
                var publicIpResponse = AzureResourceManager.CreatePublicIpAddress(subscriptionId, resourceGroupName,
                                                                                  publicIpName, azureToken, correlationId);
                if (publicIpResponse == null)
                {
                    attempts++;
                }
                else
                {
                    attempts = retryAttempts + 1;
                    // Waiting for the public IP to be created, if the request is just Accepted and the creation is still pending.
                    if ((int)(publicIpResponse.StatusCode) == (int)HttpStatusCode.Accepted)
                    {
                        AzureResourceManager.WaitForPublicIpProvisioning(subscriptionId, resourceGroupName, publicIpName,
                                                                         retryAfter, azureToken, correlationId);
                    }
                }
            } while (attempts < retryAttempts);

            // #7 Create Network Interface
            attempts = 0;
            do
            {
                var networkInterfaceResponse = AzureResourceManager.CreateNetworkInterface(subscriptionId, resourceGroupName,
                                                                                           networkInterfaceName, networkSecurityGroupId, ipName, publicIpId, subNetId, azureToken, correlationId);
                if (networkInterfaceResponse == null)
                {
                    attempts++;
                }
                else
                {
                    attempts = retryAttempts + 1;
                    // Waiting for the network interface to be created, if the request is just Accepted and the creation is still pending.
                    if ((int)(networkInterfaceResponse.StatusCode) == (int)HttpStatusCode.Accepted)
                    {
                        AzureResourceManager.WaitForNetworkInterfaceProvisioning(subscriptionId, resourceGroupName,
                                                                                 networkInterfaceName, retryAfter, azureToken, correlationId);
                    }
                }
            } while (attempts < retryAttempts);

            // #8 Create Azure Virtual Machine
            // Compute Resource Provider
            const string computeProviderName = "Microsoft.Compute";

            AzureResourceManager.RegisterProvider(subscriptionId, computeProviderName, azureToken, correlationId);
            var virtualMachineResponse = AzureResourceManager.CreateVirtualMachine(subscriptionId, resourceGroupName,
                                                                                   networkInterfaceId, storageAccountName, vitualMachineName, azureToken, correlationId);

            if (virtualMachineResponse == null)
            {
                return;
            }

            // #9  Create a New User
            var newUserInfo = User.PopulateUserFromConsole();
            var newUser     = AzureResourceManager.CreateUser(newUserInfo.displayName, newUserInfo.mailNickname,
                                                              newUserInfo.userPrincipalName, newUserInfo.password,
                                                              azureToken, correlationId);
            // #10 Add user to Owner role
            // Register the subscription with Authorization Provider
            const string authorizationProviderName = "Microsoft.Authorization";
            var          registrationResult        = AzureResourceManager.RegisterProvider(subscriptionId, authorizationProviderName, azureToken, correlationId);

            // Role Id for Role 'Owner'
            const string roleIdForOwner = "8e3af657-a8ff-443c-a75c-2fe8c4bcb635";
            var          scope          = String.Format("/subscriptions/{0}", subscriptionId);
            // Assigning 'Owner' role to the new user
            var roleAssignment = AzureResourceManager.CreateRoleAssignment(azureToken, scope, newUser.objectId, roleIdForOwner,
                                                                           correlationId);
        }