public static SqlVirtualMachineGroup CreateSqlVirtualMachineGroup(SqlVirtualMachineTestContext context, StorageAccount storageAccount, string groupName = null, WsfcDomainProfile profile = null) { ISqlVirtualMachineGroupsOperations sqlOperations = context.getSqlClient().SqlVirtualMachineGroups; StorageAccountListKeysResult storageAccountKeys = context.client.storageClient.StorageAccounts.ListKeys(context.resourceGroup.Name, storageAccount.Name); IEnumerator <StorageAccountKey> iter = storageAccountKeys.Keys.GetEnumerator(); iter.MoveNext(); string key = iter.Current.Value; string blobAccount = storageAccount.PrimaryEndpoints.Blob; if (groupName == null) { groupName = context.generateResourceName(); } SqlVirtualMachineGroup group = sqlOperations.CreateOrUpdate(context.resourceGroup.Name, groupName, new SqlVirtualMachineGroup { Location = context.location, SqlImageOffer = Constants.imageOffer, SqlImageSku = Constants.imageSku, WsfcDomainProfile = (profile != null)? profile : new WsfcDomainProfile { SqlServiceAccount = getUsername(Constants.sqlService, Constants.domainName), ClusterOperatorAccount = getUsername(Constants.adminLogin, Constants.domainName), DomainFqdn = Constants.domainName + ".com", StorageAccountUrl = blobAccount, StorageAccountPrimaryKey = key } }); group.Validate(); return(group); }
public async Task StorageAccountRegenerateKey() { Sanitizer.AddJsonPathSanitizer("$.keys.[*].value"); //create storage account and get keys string accountName = await CreateValidAccountNameAsync(namePrefix); _resourceGroup = await CreateResourceGroupAsync(); StorageAccountContainer storageAccountContainer = _resourceGroup.GetStorageAccounts(); StorageAccount account1 = (await storageAccountContainer.CreateOrUpdateAsync(accountName, GetDefaultStorageAccountParameters())).Value; VerifyAccountProperties(account1, true); StorageAccountListKeysResult keys = await account1.GetKeysAsync(); Assert.NotNull(keys); StorageAccountKey key2 = keys.Keys.First( t => StringComparer.OrdinalIgnoreCase.Equals(t.KeyName, "key2")); Assert.NotNull(key2); //regenerate key and verify the key's change StorageAccountRegenerateKeyParameters keyParameters = new StorageAccountRegenerateKeyParameters("key2"); StorageAccountListKeysResult regenKeys = await account1.RegenerateKeyAsync(keyParameters); StorageAccountKey regenKey2 = regenKeys.Keys.First( t => StringComparer.OrdinalIgnoreCase.Equals(t.KeyName, "key2")); Assert.NotNull(regenKey2); //validate the key is different from origin one if (Mode != RecordedTestMode.Playback) { Assert.AreNotEqual(key2.Value, regenKey2.Value); } }
public static async Task <CreateStorageAccountResult> CreateStorageAccount( [ActivityTrigger] CreateStorageAccountRequest storageParams, ILogger log) { log.LogWarning("Creating Storage Account in Resource Group: {resourceGroupName}", storageParams.ResourceGroupName); var storageClientProvider = Container.GetService <IAzureClientProvider <IStorageManagementClient> >(); var storageClient = await storageClientProvider.Get(storageParams.TenantID, storageParams.SubscriptionID); var saParams = new StorageAccountCreateParameters { Sku = new Microsoft.Azure.Management.Storage.Models.Sku(Microsoft.Azure.Management.Storage.Models.SkuName.StandardGRS), Location = storageParams.AzureResourceLocation, Kind = Kind.Storage, Encryption = new Encryption("Microsoft.Storage", new EncryptionServices(blob: new EncryptionService(enabled: true))), Tags = GenerateTags(storageParams) }; StorageAccount sa = await storageClient.StorageAccounts.CreateAsync(storageParams.ResourceGroupName, storageParams.StorageAccountName, saParams); log.LogWarning($"Created Storage Account {sa.Name} ({sa.Sku.Name}) in Resource Group: {storageParams.ResourceGroupName}"); StorageAccountListKeysResult keys = await storageClient.StorageAccounts.ListKeysAsync(storageParams.ResourceGroupName, storageParams.StorageAccountName); return(new CreateStorageAccountResult() { StorageAccountName = storageParams.StorageAccountName, PrimaryKey = keys.Keys.FirstOrDefault(), BlobUrl = sa.PrimaryEndpoints.Blob }); }
private async Task <StorageContainerInfo> CreateStorageContainer(SqlManagementTestContext context, ResourceGroup resourceGroup) { StorageManagementClient storageClient = context.GetClient <StorageManagementClient>(); StorageAccount storageAccount = await storageClient.StorageAccounts.CreateAsync( resourceGroup.Name, accountName : SqlManagementTestUtilities.GenerateName(prefix: "sqlvatest"), parameters : new StorageAccountCreateParameters( new Microsoft.Azure.Management.Storage.Models.Sku(SkuName.StandardLRS, SkuTier.Standard), Kind.BlobStorage, resourceGroup.Location, accessTier: AccessTier.Cool)); StorageAccountListKeysResult keys = storageClient.StorageAccounts.ListKeys(resourceGroup.Name, storageAccount.Name); string key = keys.Keys.First().Value; string containerName = "vulnerability-assessment"; var sasToken = string.Empty; // Create container // Since this is a data-plane client and not an ARM client it's harder to inject // HttpMockServer into it to record/playback, but that's fine because we don't need // any of the response data to continue with the test. if (HttpMockServer.Mode == HttpRecorderMode.Record) { CloudStorageAccount storageAccountClient = new CloudStorageAccount( new Microsoft.WindowsAzure.Storage.Auth.StorageCredentials( storageAccount.Name, key), useHttps: true); CloudBlobClient blobClient = storageAccountClient.CreateCloudBlobClient(); CloudBlobContainer containerReference = blobClient.GetContainerReference(containerName); await containerReference.CreateIfNotExistsAsync(); SharedAccessBlobPolicy sharedAccessPolicy = new SharedAccessBlobPolicy { SharedAccessExpiryTime = new DateTimeOffset(DateTime.UtcNow.Add(TimeSpan.FromHours(1))), Permissions = SharedAccessBlobPermissions.Write | SharedAccessBlobPermissions.Read | SharedAccessBlobPermissions.List }; // Generate the SAS Token sasToken = containerReference.GetSharedAccessSignature(sharedAccessPolicy); } return(new StorageContainerInfo { StorageAccountSasKey = sasToken, StorageContainerPath = new Uri(storageAccount.PrimaryEndpoints.Blob + containerName) }); }
private async Task <StorageContainerInfo> CreateStorageContainer(SqlManagementTestContext context, ResourceGroup resourceGroup) { StorageManagementClient storageClient = context.GetClient <StorageManagementClient>(); StorageAccount storageAccount = await storageClient.StorageAccounts.CreateAsync( resourceGroup.Name, accountName : SqlManagementTestUtilities.GenerateName(prefix: "sqlcrudtest"), // '-' is not allowed parameters : new StorageAccountCreateParameters( new Microsoft.Azure.Management.Storage.Models.Sku(SkuName.StandardLRS, SkuTier.Standard), Kind.BlobStorage, resourceGroup.Location, accessTier: AccessTier.Cool)); StorageAccountListKeysResult keys = storageClient.StorageAccounts.ListKeys(resourceGroup.Name, storageAccount.Name); string key = keys.Keys.First().Value; string containerName = "container"; // Create container // Since this is a data-plane client and not an ARM client it's harder to inject // HttpMockServer into it to record/playback, but that's fine because we don't need // any of the response data to continue with the test. if (HttpMockServer.Mode == HttpRecorderMode.Record) { CloudStorageAccount storageAccountClient = new CloudStorageAccount( new Microsoft.WindowsAzure.Storage.Auth.StorageCredentials( storageAccount.Name, key), useHttps: true); CloudBlobClient blobClient = storageAccountClient.CreateCloudBlobClient(); CloudBlobContainer containerReference = blobClient.GetContainerReference(containerName); await containerReference.CreateIfNotExistsAsync(); } return(new StorageContainerInfo { StorageAccountKey = key, StorageContainerUri = new Uri(storageAccount.PrimaryEndpoints.Blob + containerName) }); }
private async Task <StorageAccountInformation> CreateStorageAccountAsync(SqlManagementTestContext context, ResourceGroup resourceGroup) { string accountName = SqlManagementTestUtilities.GenerateName(prefix: StorageNamePrefix); StorageManagementClient client = context.GetClient <StorageManagementClient>(); StorageAccount storageAccount = await client.StorageAccounts.CreateAsync( resourceGroup.Name, accountName : accountName, parameters : new StorageAccountCreateParameters( new Microsoft.Azure.Management.Storage.Models.Sku(SkuName.StandardLRS, SkuTier.Standard), Kind.BlobStorage, resourceGroup.Location, accessTier: AccessTier.Cool)); StorageAccountListKeysResult keys = client.StorageAccounts.ListKeys(resourceGroup.Name, storageAccount.Name); return(new StorageAccountInformation { Name = accountName, Endpoint = storageAccount.PrimaryEndpoints.Blob, PrimaryKey = keys.Keys.First().Value }); }
/// <inheritdoc/> public async Task <BlobContainerClient> GetBlobClient(string org, string environment) { string key = $"{org}-{environment}"; if (_clients.TryGetValue(key, out BlobContainerClient client)) { return(client); } try { _accountConfig.TryGetValue(key, out StorageAccountConfig config); if (string.IsNullOrEmpty(config.AccountKey)) { StorageManagementClient storageManagementClient = new StorageManagementClient(config.SubscriptionId, _accessTokenService.GetCredential()); StorageAccountListKeysResult res = await storageManagementClient.StorageAccounts.ListKeysAsync(config.ResourceGroup, config.AccountName); config.AccountKey = res.Keys.Where(k => k.KeyName == "key1").FirstOrDefault().Value; _accountConfig[key].AccountKey = config.AccountKey; } string blobEndpoint = $"https://{config.AccountName}.blob.core.windows.net/"; BlobServiceClient commonBlobClient = new BlobServiceClient(new Uri(blobEndpoint), new StorageSharedKeyCredential(config.AccountName, config.AccountKey)); client = commonBlobClient.GetBlobContainerClient(config.Container); _clients.TryAdd(key, client); } catch (Exception e) { Console.WriteLine(e); } return(client); }
public static async Task <StorageContainerInfo> CreateStorageContainer(SqlManagementTestContext context, Microsoft.Azure.Management.ResourceManager.Models.ResourceGroup resourceGroup) { StorageManagementClient storageClient = context.GetClient <StorageManagementClient>(); StorageAccount storageAccount = await storageClient.StorageAccounts.CreateAsync( resourceGroup.Name, accountName : SqlManagementTestUtilities.GenerateName(prefix: "sqlvatest"), parameters : new StorageAccountCreateParameters( new Sku(SkuName.StandardLRS, SkuTier.Standard), Kind.BlobStorage, resourceGroup.Location, accessTier: AccessTier.Cool)); StorageAccountListKeysResult keys = storageClient.StorageAccounts.ListKeys(resourceGroup.Name, storageAccount.Name); string key = keys.Keys.First().Value; string containerName = "vulnerability-assessment"; return(new StorageContainerInfo { StorageAccountAccessKey = key, StorageContainerPath = new Uri(storageAccount.PrimaryEndpoints.Blob + containerName) }); }
public static string GetKey2(this StorageAccountListKeysResult listKeyResult) { return(listKeyResult.Keys[1].Value); }
public static string GetFirstAvailableKey(this StorageAccountListKeysResult listKeyResult) { return(listKeyResult.Keys[0].Value); }
public void ManagedDatabaseExternalBackupRestoreTest() { using (SqlManagementTestContext Context = new SqlManagementTestContext(this)) { SqlManagementClient sqlClient = Context.GetClient <SqlManagementClient>(); StorageManagementClient storageClient = Context.GetClient <StorageManagementClient>(); const string AccountName = "backupscxteam"; string testStorageContainerUri = "https://backupscxteam.blob.core.windows.net/clients"; string testStorageContainerSasToken = string.Empty; StorageAccountListKeysResult keys = storageClient.StorageAccounts.ListKeys(ManagedInstanceTestUtilities.ResourceGroupName, AccountName); string key = keys.Keys.First().Value; if (HttpMockServer.Mode == HttpRecorderMode.Record) { CloudBlobContainer container = new CloudBlobContainer( new Uri(testStorageContainerUri), new Microsoft.WindowsAzure.Storage.Auth.StorageCredentials(AccountName, key)); SharedAccessBlobPolicy sharedAccessPolicy = new SharedAccessBlobPolicy { SharedAccessExpiryTime = new DateTimeOffset(DateTime.UtcNow.Add(TimeSpan.FromHours(1))), Permissions = SharedAccessBlobPermissions.Read | SharedAccessBlobPermissions.List }; testStorageContainerSasToken = container.GetSharedAccessSignature(sharedAccessPolicy); } ResourceGroup resourceGroup = Context.CreateResourceGroup(); ManagedInstance managedInstance = Context.CreateManagedInstance(resourceGroup); string databaseName = SqlManagementTestUtilities.GenerateName(_testPrefix); // Start external backup restore. var db = sqlClient.ManagedDatabases.BeginCreateOrUpdateAsync( resourceGroup.Name, managedInstance.Name, databaseName, new ManagedDatabase() { CreateMode = "RestoreExternalBackup", Location = managedInstance.Location, Collation = managedInstance.Collation, StorageContainerUri = testStorageContainerUri, StorageContainerSasToken = testStorageContainerSasToken }).GetAwaiter().GetResult(); RetryAction(() => { var success = false; try { var dbs = sqlClient.ManagedDatabases.Get(resourceGroup.Name, managedInstance.Name, databaseName); if (dbs != null) { success = true; } } catch (Exception e) { success = false; } // Sleep if we are running live to avoid hammering the server. // No need to sleep if we are playing back the recording. if (HttpMockServer.Mode == HttpRecorderMode.Record) { Thread.Sleep(TimeSpan.FromSeconds(5)); } return(success); }); // Wait until restore state is Waiting - this means that all files have been restored from storage container. // RetryAction(() => { var restoreDetails = sqlClient.ManagedDatabaseRestoreDetails.Get(resourceGroup.Name, managedInstance.Name, databaseName); if (restoreDetails.Status == "Waiting") { return(true); } // Sleep if we are running live to avoid hammering the server. // No need to sleep if we are playing back the recording. if (HttpMockServer.Mode == HttpRecorderMode.Record) { Thread.Sleep(TimeSpan.FromSeconds(60)); } return(false); }); // Initiate restore complete request. // sqlClient.ManagedDatabases.BeginCompleteRestore(resourceGroup.Name, managedInstance.Name, databaseName, new CompleteDatabaseRestoreDefinition() { LastBackupName = "log2_0" }); // Wait until restore state is Completed. // RetryAction(() => { var restoreDetails = sqlClient.ManagedDatabaseRestoreDetails.Get(resourceGroup.Name, managedInstance.Name, databaseName); if (restoreDetails.Status == "Completed") { return(true); } // Sleep if we are running live to avoid hammering the server. // No need to sleep if we are playing back the recording. if (HttpMockServer.Mode == HttpRecorderMode.Record) { Thread.Sleep(TimeSpan.FromSeconds(30)); } return(false); }); } }
public static AvailabilityGroupListener CreateAGListener(SqlVirtualMachineTestContext context, string agListenerName, string groupName) { MockClient client = context.client; string domainName = Constants.domainName; string adminLogin = Constants.adminLogin; string adminPassword = Constants.adminPassword; // Create domain NetworkSecurityGroup nsg = CreateNsg(context); VirtualNetwork vnet = CreateVirtualNetwork(context, networkSecurityGroup: nsg); NetworkInterface nic = CreateNetworkInterface(context, virtualNetwork: vnet, networkSecurityGroup: nsg); VirtualMachine vm = CreateVM(context, nic: nic); VirtualMachineExtension domain = CreateDomain(context, vm, domainName, adminLogin, adminPassword); Assert.NotNull(domain); // Update DNS Subnet subnet = vnet.Subnets[0]; UpdateVnetDNS(context, vnet, nsg, nic, subnet); // Create SqlVirtualMachineGroup StorageAccount storageAccount = CreateStorageAccount(context); StorageAccountListKeysResult storageAccountKeys = client.storageClient.StorageAccounts.ListKeys(context.resourceGroup.Name, storageAccount.Name); IEnumerator <StorageAccountKey> iter = storageAccountKeys.Keys.GetEnumerator(); iter.MoveNext(); string key = iter.Current.Value; WsfcDomainProfile profile = new WsfcDomainProfile() { ClusterBootstrapAccount = getUsername(adminLogin, domainName), ClusterOperatorAccount = getUsername(adminLogin, domainName), SqlServiceAccount = getUsername(Constants.sqlService, domainName), StorageAccountUrl = "https://" + storageAccount.Name + ".blob.core.windows.net/", StorageAccountPrimaryKey = key, DomainFqdn = domainName + ".com", OuPath = "" }; SqlVirtualMachineGroup group = CreateSqlVirtualMachineGroup(context, storageAccount, groupName: groupName, profile: profile); // Create availability set AvailabilitySet availabilitySet = client.computeClient.AvailabilitySets.CreateOrUpdate(context.resourceGroup.Name, context.generateResourceName(), new AvailabilitySet() { Location = context.location, PlatformFaultDomainCount = 3, PlatformUpdateDomainCount = 2, Sku = new Microsoft.Azure.Management.Compute.Models.Sku { Name = "Aligned" } }); // Create two sql virtual machines NetworkInterface nic1 = CreateNetworkInterface(context, virtualNetwork: vnet); NetworkInterface nic2 = CreateNetworkInterface(context, virtualNetwork: vnet); VirtualMachine vm1 = CreateVM(context, nic: nic1, availabilitySet: availabilitySet); VirtualMachine vm2 = CreateVM(context, nic: nic2, availabilitySet: availabilitySet); SqlVirtualMachineModel sqlVM1 = prepareMachine(context, group, vm1, domainName, adminLogin, adminPassword); SqlVirtualMachineModel sqlVM2 = prepareMachine(context, group, vm2, domainName, adminLogin, adminPassword); // Create load balancer LoadBalancer loadBalancer = client.networkClient.LoadBalancers.CreateOrUpdate(context.resourceGroup.Name, context.generateResourceName(), new LoadBalancer() { Location = context.location, Sku = new LoadBalancerSku("Basic"), FrontendIPConfigurations = new List <FrontendIPConfiguration> (new FrontendIPConfiguration[] { new FrontendIPConfiguration() { Name = "LoadBalancerFrontEnd", PrivateIPAllocationMethod = "Dynamic", Subnet = subnet } }) }); // Run deployment to create an availability group with the two machines created string AgName = "AvGroup"; VirtualMachineExtension availabilityGroup = context.client.computeClient.VirtualMachineExtensions.CreateOrUpdate(context.resourceGroup.Name, vm1.Name, "agCreation", new VirtualMachineExtension(context.location, name: AgName) { VirtualMachineExtensionType = "CustomScriptExtension", Publisher = "Microsoft.Compute", TypeHandlerVersion = "1.9", AutoUpgradeMinorVersion = true, Settings = new CustomScriptExtensionSettings { FileUris = new List <string>(new string[] { "https://agtemplatestorage.blob.core.windows.net/templates/Deploy.ps1", "https://agtemplatestorage.blob.core.windows.net/templates/sqlvm6.sql", "https://agtemplatestorage.blob.core.windows.net/templates/sqlvm7.sql", "https://agtemplatestorage.blob.core.windows.net/templates/sqlvm8.sql", "https://agtemplatestorage.blob.core.windows.net/test/sqlvm9.sql", "https://agtemplatestorage.blob.core.windows.net/templates/sqlvm10.sql" }), CommandToExecute = "powershell -ExecutionPolicy Unrestricted -File Deploy.ps1 " + AgName + " " + vm1.Name + " " + vm2.Name + " " + Constants.sqlLogin + " " + adminPassword + " " + domainName + "\\" + Constants.sqlService, ContentVersion = "1.0.0.0" } }); // Create availability group listener return(context.getSqlClient().AvailabilityGroupListeners.CreateOrUpdate(context.resourceGroup.Name, group.Name, agListenerName, new AvailabilityGroupListener() { LoadBalancerConfigurations = new List <LoadBalancerConfiguration>(new LoadBalancerConfiguration[] { new LoadBalancerConfiguration() { PrivateIpAddress = new PrivateIPAddress(ipAddress: "10.0.0.11", subnetResourceId: subnet.Id), ProbePort = 59999, LoadBalancerResourceId = loadBalancer.Id, SqlVirtualMachineInstances = new List <string>() { sqlVM1.Id, sqlVM2.Id } } }), AvailabilityGroupName = AgName, Port = 1433 })); }
public static string GetKey2(this StorageAccountListKeysResult listKeyResult) { return(listKeyResult.Keys.ElementAt(1).Value); }
public static string GetFirstAvailableKey(this StorageAccountListKeysResult listKeyResult) { return(!string.IsNullOrEmpty(listKeyResult.Keys[0].Value) ? listKeyResult.Keys[0].Value : listKeyResult.Keys[1].Value); }