/** * Azure App Service sample for managing web apps. * - app service plan, web app * - Create 2 web apps under the same new app service plan * - domain * - Create a domain * - certificate * - Upload a self-signed wildcard certificate * - update both web apps to use the domain and the created wildcard SSL certificate */ public static void RunSample(IAzure azure) { string app1Name = SdkContext.RandomResourceName("webapp1-", 20); string app2Name = SdkContext.RandomResourceName("webapp2-", 20); string rgName = SdkContext.RandomResourceName("rgNEMV_", 24); string domainName = SdkContext.RandomResourceName("jsdkdemo-", 20) + ".com"; try { //============================================================ // Create a web app with a new app service plan Utilities.Log("Creating web app " + app1Name + "..."); var app1 = azure.WebApps .Define(app1Name) .WithRegion(Region.USWest) .WithNewResourceGroup(rgName) .WithNewWindowsPlan(PricingTier.StandardS1) .Create(); Utilities.Log("Created web app " + app1.Name); Utilities.Print(app1); //============================================================ // Create a second web app with the same app service plan Utilities.Log("Creating another web app " + app2Name + "..."); var plan = azure.AppServices.AppServicePlans.GetById(app1.AppServicePlanId); var app2 = azure.WebApps .Define(app2Name) .WithExistingWindowsPlan(plan) .WithExistingResourceGroup(rgName) .Create(); Utilities.Log("Created web app " + app2.Name); Utilities.Print(app2); //============================================================ // Purchase a domain (will be canceled for a full refund) Utilities.Log("Purchasing a domain " + domainName + "..."); var domain = azure.AppServices.AppServiceDomains.Define(domainName) .WithExistingResourceGroup(rgName) .DefineRegistrantContact() .WithFirstName("Jon") .WithLastName("Doe") .WithEmail("*****@*****.**") .WithAddressLine1("123 4th Ave") .WithCity("Redmond") .WithStateOrProvince("WA") .WithCountry(CountryISOCode.UnitedStates) .WithPostalCode("98052") .WithPhoneCountryCode(CountryPhoneCode.UnitedStates) .WithPhoneNumber("4258828080") .Attach() .WithDomainPrivacyEnabled(true) .WithAutoRenewEnabled(false) .Create(); Utilities.Log("Purchased domain " + domain.Name); Utilities.Print(domain); //============================================================ // Bind domain to web app 1 Utilities.Log("Binding http://" + app1Name + "." + domainName + " to web app " + app1Name + "..."); app1 = app1.Update() .DefineHostnameBinding() .WithAzureManagedDomain(domain) .WithSubDomain(app1Name) .WithDnsRecordType(CustomHostNameDnsRecordType.CName) .Attach() .Apply(); Utilities.Log("Finished binding http://" + app1Name + "." + domainName + " to web app " + app1Name); Utilities.Print(app1); //============================================================ // Create a self-singed SSL certificate var pfxPath = "webapp_" + nameof(ManageWebAppWithDomainSsl).ToLower() + ".pfx"; Utilities.Log("Creating a self-signed certificate " + pfxPath + "..."); Utilities.CreateCertificate(domainName, pfxPath, CertificatePassword); Utilities.Log("Created self-signed certificate " + pfxPath); //============================================================ // Bind domain to web app 2 and turn on wild card SSL for both Utilities.Log("Binding https://" + app1Name + "." + domainName + " to web app " + app1Name + "..."); app1 = app1.Update() .WithManagedHostnameBindings(domain, app1Name) .DefineSslBinding() .ForHostname(app1Name + "." + domainName) .WithPfxCertificateToUpload(Path.Combine(Utilities.ProjectPath, "Asset", pfxPath), CertificatePassword) .WithSniBasedSsl() .Attach() .Apply(); Utilities.Log("Finished binding https://" + app1Name + "." + domainName + " to web app " + app1Name); Utilities.Print(app1); Utilities.Log("Binding https://" + app2Name + "." + domainName + " to web app " + app2Name + "..."); app2 = app2.Update() .WithManagedHostnameBindings(domain, app2Name) .DefineSslBinding() .ForHostname(app2Name + "." + domainName) .WithPfxCertificateToUpload(Path.Combine(Utilities.ProjectPath, "Asset", pfxPath), CertificatePassword) .WithSniBasedSsl() .Attach() .Apply(); Utilities.Log("Finished binding https://" + app2Name + "." + domainName + " to web app " + app2Name); Utilities.Print(app2); } 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); } } }
// This method will be called for each input received from the pipeline to this cmdlet; if no input is received, this method is not called protected override void ProcessRecord() { ProgressRecord progress = new ProgressRecord(1, "SimpleSwarm Setup", "Connecting to Azure..."); WriteProgress(progress); var credentials = SdkContext.AzureCredentialsFactory.FromFile(Environment.GetEnvironmentVariable("AZURE_AUTH_LOCATION")); var azure = Microsoft.Azure.Management.Fluent.Azure .Configure() .Authenticate(credentials) .WithDefaultSubscription(); progress = new ProgressRecord(1, "SimpleSwarm Setup", "Creating Resource Group..."); WriteProgress(progress); IResourceGroup resourceGroup = azure.ResourceGroups .Define(resourceGroupName) .WithRegion(location) .Create(); progress = new ProgressRecord(1, "SimpleSwarm Setup", "Creating Swarm Manager Identity..."); WriteProgress(progress); IIdentity identityManager = azure.Identities .Define("AzSwarmManager") .WithRegion(location) .WithExistingResourceGroup(resourceGroup) .Create(); progress = new ProgressRecord(1, "SimpleSwarm Setup", "Creating Swarm Worker Identity..."); WriteProgress(progress); IIdentity identityWorker = azure.Identities .Define("AzSwarmWorker") .WithRegion(location) .WithExistingResourceGroup(resourceGroup) .Create(); progress = new ProgressRecord(1, "SimpleSwarm Setup", "Creating Key Vault..."); WriteProgress(progress); IVault keyVault = azure.Vaults .Define(SdkContext.RandomResourceName("azswarmkv-", 20)) .WithRegion(location) .WithExistingResourceGroup(resourceGroup) .WithEmptyAccessPolicy().Create(); progress = new ProgressRecord(1, "SimpleSwarm Setup", "Updating Key Vault Swarm Manager Access Policy..."); WriteProgress(progress); keyVault.Update() .DefineAccessPolicy() .ForObjectId(identityManager.PrincipalId) .AllowSecretAllPermissions() .Attach() .Apply(); progress = new ProgressRecord(1, "SimpleSwarm Setup", "Updating Key Vault Swarm Worker Access Policy..."); WriteProgress(progress); keyVault.Update() .DefineAccessPolicy() .ForObjectId(identityWorker.PrincipalId) .AllowSecretPermissions(SecretPermissions.Get) .AllowSecretPermissions(SecretPermissions.List) .Attach() .Apply(); progress = new ProgressRecord(1, "SimpleSwarm Setup", "Creating Virtual Network..."); WriteProgress(progress); INetwork network = azure.Networks .Define(SdkContext.RandomResourceName("AzSwarmNetwork", 20)) .WithRegion(location) .WithExistingResourceGroup(resourceGroup) .WithAddressSpace("10.0.0.0/16") .WithSubnet("AzSwarmSubnet", "10.0.0.0/24") .Create(); progress = new ProgressRecord(1, "SimpleSwarm Setup", "Creating Storage Account..."); WriteProgress(progress); IStorageAccount storage = azure.StorageAccounts .Define(SdkContext.RandomResourceName("azswarmst", 20)) .WithRegion(location) .WithExistingResourceGroup(resourceGroup) .WithAccessFromAllNetworks() .WithAccessFromAzureServices() .WithGeneralPurposeAccountKindV2() .WithOnlyHttpsTraffic() .WithSku(StorageAccountSkuType.Standard_LRS) .Create(); progress = new ProgressRecord(1, "SimpleSwarm Setup", "Creating Storage Account Table..."); WriteProgress(progress); var storageAccountAccessKeys = storage.GetKeys(); string storageConnectionString = "DefaultEndpointsProtocol=https" + ";AccountName=" + storage.Name + ";AccountKey=" + storageAccountAccessKeys[0].Value + ";EndpointSuffix=core.windows.net"; var cloudStorageAccount = CloudStorageAccount.Parse(storageConnectionString); CloudTableClient tableClient = cloudStorageAccount.CreateCloudTableClient(new TableClientConfiguration()); CloudTable table = tableClient.GetTableReference("SimpleSwarmSetup"); table.CreateIfNotExists(); progress = new ProgressRecord(1, "SimpleSwarm Setup", "Creating Manager Availability Set..."); WriteProgress(progress); IAvailabilitySet availabilitySetManager = azure.AvailabilitySets.Define("azswarm-manager-avset") .WithRegion(location) .WithExistingResourceGroup(resourceGroup) .WithFaultDomainCount(3) .WithUpdateDomainCount(5) .Create(); progress = new ProgressRecord(1, "SimpleSwarm Setup", "Creating Manager Availability Set..."); WriteProgress(progress); IAvailabilitySet availabilitySetWorker = azure.AvailabilitySets.Define("azswarm-worker-avset") .WithRegion(location) .WithExistingResourceGroup(resourceGroup) .WithFaultDomainCount(3) .WithUpdateDomainCount(5) .Create(); WriteVerbose("SimpleSwarm Setup Completed"); }
public void CanCRUDCassandraTable() { using (var context = FluentMockContext.Start(GetType().FullName)) { var dbName = SdkContext.RandomResourceName("cosmosdb", 22); var rgName = SdkContext.RandomResourceName("cosmosdbRg", 22); var cassandraName = SdkContext.RandomResourceName("cassandra", 22); var cassandraTableName = SdkContext.RandomResourceName("cassandratable", 22); var region = Region.USWest; var azure = TestHelper.CreateRollupClient(); try { azure.ResourceGroups.Define(rgName).WithRegion(region).Create(); var databaseAccount = azure.CosmosDBAccounts.Define(dbName) .WithRegion(region) .WithExistingResourceGroup(rgName) .WithDataModelCassandra() .WithStrongConsistency() .DefineNewCassandraKeyspace(cassandraName) .WithThroughput(400) .DefineNewCassandraTable(cassandraTableName) .WithThroughput(600) .WithColumn("id", "int") .WithColumn("name", "text") .WithColumn("test", "boolean") .WithPartitionKey("id") .Attach() .Attach() .Create(); var cassandras = databaseAccount.ListCassandraKeyspaces().ToList(); Assert.Single(cassandras); var cassandra = cassandras[0]; Assert.Equal(cassandraName, cassandra.Name); Assert.Equal(400, cassandra.GetThroughputSettings().Throughput); var tables = cassandra.ListCassandraTables().ToList(); Assert.Single(tables); var table = tables[0]; Assert.Equal(cassandraTableName, table.Name); Assert.Equal(600, table.GetThroughputSettings().Throughput); Assert.Equal(3, table.Schema.Columns.Count); Assert.Equal(1, table.Schema.PartitionKeys.Count); Assert.Equal("id", table.Schema.PartitionKeys[0].Name); databaseAccount = databaseAccount.Update() .UpdateCassandraKeyspace(cassandraName) .UpdateCassandraTable(cassandraTableName) .WithThroughput(500) .WithoutColumn("test") .Parent() .WithThroughput(800) .Parent() .Apply(); cassandra = databaseAccount.GetCassandraKeyspace(cassandraName); Assert.Equal(800, cassandra.GetThroughputSettings().Throughput); table = cassandra.GetCassandraTable(cassandraTableName); Assert.Equal(500, table.GetThroughputSettings().Throughput); Assert.Equal(2, table.Schema.Columns.Count); Assert.Null(table.Schema.Columns.SingleOrDefault(element => element.Name == "test")); } finally { try { azure.ResourceGroups.BeginDeleteByName(rgName); } catch { } } } }
public void CanCRUDGremlinGraph() { using (var context = FluentMockContext.Start(GetType().FullName)) { var dbName = SdkContext.RandomResourceName("cosmosdb", 22); var rgName = SdkContext.RandomResourceName("cosmosdbRg", 22); var gremlinName = SdkContext.RandomResourceName("gremlin", 22); var gremlinGraphName = SdkContext.RandomResourceName("gremlingraph", 22); var region = Region.USWest; var azure = TestHelper.CreateRollupClient(); try { azure.ResourceGroups.Define(rgName).WithRegion(region).Create(); var databaseAccount = azure.CosmosDBAccounts.Define(dbName) .WithRegion(region) .WithExistingResourceGroup(rgName) .WithDataModelGremlin() .WithStrongConsistency() .DefineNewGremlinDatabase(gremlinName) .WithThroughput(1000) .DefineNewGremlinGraph(gremlinGraphName) .WithThroughput(400) .DefineIndexingPolicy() .WithIndexingMode(IndexingMode.Consistent) .WithIncludedPath(new IncludedPath(path: "/*")) .WithExcludedPath(new ExcludedPath(path: "/myPathToNotIndex/*")) .Attach() .WithPartitionKey(paths: new List <string>() { "/myPartitionKey" }, kind: PartitionKind.Hash, version: null) .Attach() .Attach() .Create(); var gremlins = databaseAccount.ListGremlinDatabases().ToList(); Assert.Single(gremlins); var gremlin = gremlins[0]; Assert.Equal(gremlinName, gremlin.Name); Assert.Equal(1000, gremlin.GetThroughputSettings().Throughput); var graphs = gremlin.ListGremlinGraphs().ToList(); Assert.Single(graphs); var graph = graphs[0]; Assert.Equal(gremlinGraphName, graph.Name); Assert.Equal(400, graph.GetThroughputSettings().Throughput); Assert.Equal(IndexingMode.Consistent, graph.IndexingPolicy.IndexingMode); Assert.NotNull(graph.IndexingPolicy.IncludedPaths.Single(element => element.Path == "/*")); Assert.NotNull(graph.IndexingPolicy.ExcludedPaths.Single(element => element.Path == "/myPathToNotIndex/*")); Assert.True(graph.PartitionKey.Paths.Contains("/myPartitionKey")); Assert.Equal(PartitionKind.Hash, graph.PartitionKey.Kind); databaseAccount = databaseAccount.Update() .UpdateGremlinDatabase(gremlinName) .WithThroughput(800) .UpdateGremlinGraph(gremlinGraphName) .WithThroughput(600) .Parent() .Parent() .Apply(); gremlin = databaseAccount.GetGremlinDatabase(gremlinName); Assert.Equal(800, gremlin.GetThroughputSettings().Throughput); graph = gremlin.GetGremlinGraph(gremlinGraphName); Assert.Equal(600, graph.GetThroughputSettings().Throughput); } finally { try { azure.ResourceGroups.BeginDeleteByName(rgName); } catch { } } } }
public void CanCreateImageFromNativeVhd() { using (var context = FluentMockContext.Start(GetType().FullName)) { var vhdBasedImageName = SdkContext.RandomResourceName("img", 20); var resourceManager = TestHelper.CreateRollupClient(); var computeManager = TestHelper.CreateComputeManager(); var rgName = TestUtilities.GenerateName("rgfluentchash-"); try { var linuxVM = PrepareGeneralizedVMWith2EmptyDataDisks(rgName, SdkContext.RandomResourceName("muldvm", 15), Location, computeManager); // var creatableDisk = computeManager.VirtualMachineCustomImages.Define(vhdBasedImageName) .WithRegion(Location) .WithNewResourceGroup(rgName) .WithLinuxFromVhd(linuxVM.OSUnmanagedDiskVhdUri, OperatingSystemStateTypes.Generalized) .WithOSDiskCaching(linuxVM.OSDiskCachingType); foreach (var 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(); } var customImage = creatableDisk.Create(); Assert.NotNull(customImage.Id); Assert.Equal(customImage.Name, vhdBasedImageName); Assert.False(customImage.IsCreatedFromVirtualMachine); Assert.Null(customImage.SourceVirtualMachineId); Assert.NotNull(customImage.OSDiskImage); Assert.NotNull(customImage.OSDiskImage.BlobUri); Assert.Equal(CachingTypes.ReadWrite, customImage.OSDiskImage.Caching); Assert.Equal(OperatingSystemStateTypes.Generalized, customImage.OSDiskImage.OsState); Assert.Equal(OperatingSystemTypes.Linux, customImage.OSDiskImage.OsType); Assert.NotNull(customImage.DataDiskImages); Assert.Equal(customImage.DataDiskImages.Count, linuxVM.UnmanagedDataDisks.Count); Assert.Equal(customImage.HyperVGeneration, HyperVGenerationTypes.V1); foreach (ImageDataDisk diskImage in customImage.DataDiskImages.Values) { IVirtualMachineUnmanagedDataDisk matchedDisk = null; foreach (var vmDisk in linuxVM.UnmanagedDataDisks.Values) { if (vmDisk.Lun == diskImage.Lun) { matchedDisk = vmDisk; break; } } Assert.NotNull(matchedDisk); Assert.Equal(matchedDisk.CachingType, diskImage.Caching); Assert.Equal(matchedDisk.VhdUri, diskImage.BlobUri); Assert.Equal((long)matchedDisk.Size + 10, (long)diskImage.DiskSizeGB); } var image = computeManager .VirtualMachineCustomImages .GetByResourceGroup(rgName, vhdBasedImageName); Assert.NotNull(image); var images = computeManager .VirtualMachineCustomImages .ListByResourceGroup(rgName); Assert.True(images.Count() > 0); // Create virtual machine from custom image // var virtualMachine = computeManager.VirtualMachines .Define(SdkContext.RandomResourceName("cusvm", 15)) .WithRegion(Location) .WithNewResourceGroup(rgName) .WithNewPrimaryNetwork("10.0.0.0/28") .WithPrimaryPrivateIPAddressDynamic() .WithoutPrimaryPublicIPAddress() .WithLinuxCustomImage(image.Id) .WithRootUsername("javauser") .WithRootPassword("12NewPA$$w0rd!") .WithSize(VirtualMachineSizeTypes.StandardD5V2) .WithOSDiskCaching(CachingTypes.ReadWrite) .Create(); var dataDisks = virtualMachine.DataDisks; Assert.NotNull(dataDisks); Assert.Equal(dataDisks.Count, image.DataDiskImages.Count); //Create a hyperv Gen2 image var creatableDiskGen2 = computeManager .VirtualMachineCustomImages .Define(vhdBasedImageName + "Gen2") .WithRegion(Location) .WithNewResourceGroup(rgName) .WithHyperVGeneration(HyperVGenerationTypes.V2) .WithLinuxFromVhd(linuxVM.OSUnmanagedDiskVhdUri, OperatingSystemStateTypes.Generalized) .WithOSDiskCaching(linuxVM.OSDiskCachingType); foreach (var 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 customImageGen2 = creatableDiskGen2.Create(); Assert.NotNull(customImageGen2.Id); Assert.Equal(customImageGen2.Name, vhdBasedImageName + "Gen2"); Assert.False(customImageGen2.IsCreatedFromVirtualMachine); Assert.Null(customImageGen2.SourceVirtualMachineId); Assert.NotNull(customImageGen2.OSDiskImage); Assert.NotNull(customImageGen2.OSDiskImage); Assert.Equal(CachingTypes.ReadWrite, customImageGen2.OSDiskImage.Caching); Assert.Equal(OperatingSystemStateTypes.Generalized, customImageGen2.OSDiskImage.OsState); Assert.Equal(OperatingSystemTypes.Linux, customImageGen2.OSDiskImage.OsType); Assert.NotNull(customImageGen2.DataDiskImages); Assert.Equal(0, customImageGen2.DataDiskImages.Count); Assert.Equal(customImageGen2.HyperVGeneration, HyperVGenerationTypes.V2); } finally { try { resourceManager.ResourceGroups.DeleteByName(rgName); } catch { } } } }
public void CanCRUDMongoDBCollection() { using (var context = FluentMockContext.Start(GetType().FullName)) { var dbName = SdkContext.RandomResourceName("cosmosdb", 22); var rgName = SdkContext.RandomResourceName("cosmosdbRg", 22); var mongoDBName = SdkContext.RandomResourceName("mongodb", 22); var mongoCollectionName = SdkContext.RandomResourceName("mongocollection", 22); var region = Region.USWest; var azure = TestHelper.CreateRollupClient(); try { azure.ResourceGroups.Define(rgName).WithRegion(region).Create(); var databaseAccount = azure.CosmosDBAccounts.Define(dbName) .WithRegion(region) .WithExistingResourceGroup(rgName) .WithDataModelMongoDB() .WithStrongConsistency() .DefineNewMongoDB(mongoDBName) .WithThroughput(400) .DefineNewCollection(mongoCollectionName) .WithThroughput(600) .WithShardKey("test") .Attach() .Attach() .Create(); var mongodbs = databaseAccount.ListMongoDBs().ToList(); Assert.Single(mongodbs); var mongodb = mongodbs[0]; Assert.Equal(mongoDBName, mongodb.Name); Assert.Equal(400, mongodb.GetThroughputSettings().Throughput); var collections = mongodb.ListCollections().ToList(); Assert.Single(collections); var collection = collections[0]; Assert.Equal(mongoCollectionName, collection.Name); Assert.Equal(600, collection.GetThroughputSettings().Throughput); Assert.Equal("Hash", collection.ShardKey.GetValueOrDefault("test", "empty")); databaseAccount = databaseAccount.Update() .UpdateMongoDB(mongoDBName) .UpdateCollection(mongoCollectionName) .WithThroughput(500) .Parent() .WithThroughput(800) .Parent() .Apply(); mongodb = databaseAccount.GetMongoDB(mongoDBName); Assert.Equal(800, mongodb.GetThroughputSettings().Throughput); collection = mongodb.GetCollection(mongoCollectionName); Assert.Equal(500, collection.GetThroughputSettings().Throughput); } finally { try { azure.ResourceGroups.BeginDeleteByName(rgName); } catch { } } } }
/** * Azure sample for applying locks to resources * * Summary ... * * This sample shows examples of management locks usage on various resources. * * Details ... * * 1. Create a number of various resources to apply locks to... * 2. Apply various locks to the resources * 3. Retrieve and show lock information * 4. Remove the locks and clean up */ public static void RunSample(IAzure azure) { string password = SdkContext.RandomResourceName("P@s", 14); string rgName = SdkContext.RandomResourceName("rg", 15); string vmName = SdkContext.RandomResourceName("vm", 15); string storageName = SdkContext.RandomResourceName("st", 15); string diskName = SdkContext.RandomResourceName("dsk", 15); string netName = SdkContext.RandomResourceName("net", 15); Region region = Region.USEast; IResourceGroup resourceGroup = null; IManagementLock lockGroup = null, lockVM = null, lockStorage = null, lockDiskRO = null, lockDiskDel = null, lockSubnet = null; try { //============================================================= // Create a shared resource group for all the resources so they can all be deleted together // resourceGroup = azure.ResourceGroups.Define(rgName) .WithRegion(region) .Create(); Utilities.Log("Created a new resource group - " + resourceGroup.Id); //============================================================ // Create various resources for demonstrating locks // // Define a network to apply a lock to ICreatable <INetwork> netDefinition = azure.Networks.Define(netName) .WithRegion(region) .WithExistingResourceGroup(resourceGroup) .WithAddressSpace("10.0.0.0/28"); // Define a managed disk for testing locks on that ICreatable <IDisk> diskDefinition = azure.Disks.Define(diskName) .WithRegion(region) .WithExistingResourceGroup(resourceGroup) .WithData() .WithSizeInGB(100); // Define a VM to apply a lock to ICreatable <IVirtualMachine> vmDefinition = azure.VirtualMachines.Define(vmName) .WithRegion(region) .WithExistingResourceGroup(resourceGroup) .WithNewPrimaryNetwork(netDefinition) .WithPrimaryPrivateIPAddressDynamic() .WithoutPrimaryPublicIPAddress() .WithPopularWindowsImage(KnownWindowsVirtualMachineImage.WindowsServer2012Datacenter) .WithAdminUsername("tester") .WithAdminPassword(password) .WithNewDataDisk(diskDefinition, 1, CachingTypes.None) .WithSize(VirtualMachineSizeTypes.BasicA1); // Define a storage account to apply a lock to ICreatable <IStorageAccount> storageDefinition = azure.StorageAccounts.Define(storageName) .WithRegion(region) .WithExistingResourceGroup(resourceGroup); // Create resources in parallel to save time Utilities.Log("Creating the needed resources..."); Task.WaitAll( storageDefinition.CreateAsync(), vmDefinition.CreateAsync()); Utilities.Log("Resources created."); IVirtualMachine vm = (IVirtualMachine)vmDefinition; IStorageAccount storage = (IStorageAccount)storageDefinition; IDisk disk = (IDisk)diskDefinition; INetwork network = vm.GetPrimaryNetworkInterface().PrimaryIPConfiguration.GetNetwork(); ISubnet subnet = network.Subnets.Values.FirstOrDefault(); //============================================================ // Create various locks for the created resources // // Locks can be created serially, and multiple can be applied to the same resource: Utilities.Log("Creating locks sequentially..."); // Apply a ReadOnly lock to the disk lockDiskRO = azure.ManagementLocks.Define("diskLockRO") .WithLockedResource(disk) .WithLevel(LockLevel.ReadOnly) .Create(); // Apply a lock preventing the disk from being deleted lockDiskDel = azure.ManagementLocks.Define("diskLockDel") .WithLockedResource(disk) .WithLevel(LockLevel.CanNotDelete) .Create(); // Locks can also be created in parallel, for better overall performance: Utilities.Log("Creating locks in parallel..."); // Define a subnet lock ICreatable <IManagementLock> lockSubnetDef = azure.ManagementLocks.Define("subnetLock") .WithLockedResource(subnet.Inner.Id) .WithLevel(LockLevel.ReadOnly); // Define a VM lock ICreatable <IManagementLock> lockVMDef = azure.ManagementLocks.Define("vmlock") .WithLockedResource(vm) .WithLevel(LockLevel.ReadOnly) .WithNotes("vm readonly lock"); // Define a resource group lock ICreatable <IManagementLock> lockGroupDef = azure.ManagementLocks.Define("rglock") .WithLockedResource(resourceGroup.Id) .WithLevel(LockLevel.CanNotDelete); // Define a storage lock ICreatable <IManagementLock> lockStorageDef = azure.ManagementLocks.Define("stLock") .WithLockedResource(storage) .WithLevel(LockLevel.CanNotDelete); var created = azure.ManagementLocks.Create( lockVMDef, lockGroupDef, lockStorageDef, lockSubnetDef); lockVM = created.FirstOrDefault(o => o.Key.Equals(lockVMDef.Key, StringComparison.OrdinalIgnoreCase)); lockStorage = created.FirstOrDefault(o => o.Key.Equals(lockStorageDef.Key, StringComparison.OrdinalIgnoreCase)); lockGroup = created.FirstOrDefault(o => o.Key.Equals(lockGroupDef.Key, StringComparison.OrdinalIgnoreCase)); lockSubnet = created.FirstOrDefault(o => o.Key.Equals(lockSubnetDef.Key, StringComparison.OrdinalIgnoreCase)); Utilities.Log("Locks created."); //============================================================ // Retrieve and show lock information // // Count and show locks (Note: locks returned for a resource include the locks for its resource group and child resources) int lockCount = azure.ManagementLocks.ListForResource(vm.Id).Count(); Utilities.Log("Number of locks applied to the virtual machine: " + lockCount); lockCount = azure.ManagementLocks.ListByResourceGroup(resourceGroup.Name).Count(); Utilities.Log("Number of locks applied to the resource group (includes locks on resources in the group): " + lockCount); lockCount = azure.ManagementLocks.ListForResource(storage.Id).Count(); Utilities.Log("Number of locks applied to the storage account: " + lockCount); lockCount = azure.ManagementLocks.ListForResource(disk.Id).Count(); Utilities.Log("Number of locks applied to the managed disk: " + lockCount); lockCount = azure.ManagementLocks.ListForResource(network.Id).Count(); Utilities.Log("Number of locks applied to the network (including its subnets): " + lockCount); // Locks can be retrieved using their ID lockVM = azure.ManagementLocks.GetById(lockVM.Id); lockGroup = azure.ManagementLocks.GetByResourceGroup(resourceGroup.Name, "rglock"); lockStorage = azure.ManagementLocks.GetById(lockStorage.Id); lockDiskRO = azure.ManagementLocks.GetById(lockDiskRO.Id); lockDiskDel = azure.ManagementLocks.GetById(lockDiskDel.Id); lockSubnet = azure.ManagementLocks.GetById(lockSubnet.Id); // Show the locks Utilities.Print(lockGroup); Utilities.Print(lockVM); Utilities.Print(lockDiskDel); Utilities.Print(lockDiskRO); Utilities.Print(lockStorage); Utilities.Print(lockSubnet); // List all locks within a subscription var locksSubscription = azure.ManagementLocks.List(); Utilities.Log("Total number of locks within this subscription: " + locksSubscription.Count()); } finally { try { // Clean up (remember to unlock resources before deleting the resource group) azure.ManagementLocks.DeleteByIds( lockGroup.Id, lockVM.Id, lockDiskRO.Id, lockDiskDel.Id, lockStorage.Id, lockSubnet.Id); 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); } } }
/** * This sample shows examples of configuring Metric Alerts for WebApp instance performance monitoring through app service plan. * - Create a App Service plan * - Setup an action group to trigger a notification to the heavy performance alerts * - Create auto-mitigated metric alerts for the App Service plan when * - average CPUPercentage on any of Web App instance (where Instance = *) over the last 5 minutes is above 80% */ public static void RunSample(IAzure azure) { string storageAccountName = SdkContext.RandomResourceName("saMonitor", 15); string rgName = SdkContext.RandomResourceName("rgMonitor", 15); try { // ============================================================ // Create an App Service plan Utilities.Log("Creating App Service plan"); var servicePlan = azure.AppServices.AppServicePlans.Define("HighlyAvailableWebApps") .WithRegion(Region.USEast2) .WithNewResourceGroup(rgName) .WithPricingTier(PricingTier.PremiumP1) .WithOperatingSystem(Microsoft.Azure.Management.AppService.Fluent.OperatingSystem.Windows) .Create(); Utilities.Log("App Service plan created:"); Utilities.Print(servicePlan); // ============================================================ // Create an action group to send notifications in case metric alert condition will be triggered var ag = azure.ActionGroups.Define("criticalPerformanceActionGroup") .WithExistingResourceGroup(rgName) .DefineReceiver("tierOne") .WithPushNotification("*****@*****.**") .WithEmail("*****@*****.**") .WithSms("1", "4255655665") .WithVoice("1", "2062066050") .WithWebhook("https://www.weeneedmorepower.performancemonitoring.com") .Attach() .DefineReceiver("tierTwo") .WithEmail("*****@*****.**") .Attach() .Create(); Utilities.Print(ag); // ============================================================ // Set a trigger to fire each time var ma = azure.AlertRules.MetricAlerts.Define("Critical performance alert") .WithExistingResourceGroup(rgName) .WithTargetResource(servicePlan.Id) .WithPeriod(TimeSpan.FromMinutes(5)) .WithFrequency(TimeSpan.FromMinutes(1)) .WithAlertDetails(3, "This alert rule is for U5 - Single resource-multiple criteria - with dimensions - with star") .WithActionGroups(ag.Id) .DefineAlertCriteria("Metric1") .WithMetricName("CPUPercentage", "Microsoft.Web/serverfarms") .WithCondition(MetricAlertRuleTimeAggregation.Total, MetricAlertRuleCondition.GreaterThan, 80) .WithDimension("Instance", "*") .Attach() .Create(); Utilities.Print(ma); } finally { if (azure.ResourceGroups.GetByName(rgName) != null) { Utilities.Log("Deleting Resource Group: " + rgName); azure.ResourceGroups.BeginDeleteByName(rgName); Utilities.Log("Deleted Resource Group: " + rgName); } else { Utilities.Log("Did not create any resources in Azure. No clean up is necessary"); } } }
///GENMHASH:233A62609A15DC3B8EB48DD8DB699DDC:5F2825180653A2E415C39BF41FD682D6 internal NicIPConfigurationImpl WithNewPublicIPAddress(string leafDnsLabel) { return(WithNewPublicIPAddress( PrepareCreatablePublicIP(SdkContext.RandomResourceName("pip", 15), leafDnsLabel))); }
/** * Azure Network sample for managing network security groups - * - Create a network security group for the front end of a subnet * - Create a network security group for the back end of a subnet * - Create Linux virtual machines for the front end and back end * -- Apply network security groups * - List network security groups * - Update a network security group. */ public static void RunSample(IAzure azure) { string frontEndNSGName = SdkContext.RandomResourceName("fensg", 24); string backEndNSGName = SdkContext.RandomResourceName("bensg", 24); string rgName = SdkContext.RandomResourceName("rgNEMS", 24); string vnetName = SdkContext.RandomResourceName("vnet", 24); string networkInterfaceName1 = SdkContext.RandomResourceName("nic1", 24); string networkInterfaceName2 = SdkContext.RandomResourceName("nic2", 24); string publicIPAddressLeafDNS1 = SdkContext.RandomResourceName("pip1", 24); string frontEndVMName = SdkContext.RandomResourceName("fevm", 24); string backEndVMName = SdkContext.RandomResourceName("bevm", 24); try { // Define a virtual network for VMs in this availability set Utilities.Log("Creating a virtual network ..."); var network = azure.Networks.Define(vnetName) .WithRegion(Region.USEast) .WithNewResourceGroup(rgName) .WithAddressSpace("172.16.0.0/16") .DefineSubnet("Front-end") .WithAddressPrefix("172.16.1.0/24") .Attach() .DefineSubnet("Back-end") .WithAddressPrefix("172.16.2.0/24") .Attach() .Create(); Utilities.Log("Created a virtual network: " + network.Id); Utilities.PrintVirtualNetwork(network); //============================================================ // Create a network security group for the front end of a subnet // front end subnet contains two rules // - ALLOW-SSH - allows SSH traffic into the front end subnet // - ALLOW-WEB- allows HTTP traffic into the front end subnet Utilities.Log("Creating a security group for the front end - allows SSH and HTTP"); var frontEndNSG = azure.NetworkSecurityGroups.Define(frontEndNSGName) .WithRegion(Region.USEast) .WithNewResourceGroup(rgName) .DefineRule("ALLOW-SSH") .AllowInbound() .FromAnyAddress() .FromAnyPort() .ToAnyAddress() .ToPort(22) .WithProtocol(SecurityRuleProtocol.Tcp) .WithPriority(100) .WithDescription("Allow SSH") .Attach() .DefineRule("ALLOW-HTTP") .AllowInbound() .FromAnyAddress() .FromAnyPort() .ToAnyAddress() .ToPort(80) .WithProtocol(SecurityRuleProtocol.Tcp) .WithPriority(101) .WithDescription("Allow HTTP") .Attach() .Create(); Utilities.Log("Created a security group for the front end: " + frontEndNSG.Id); Utilities.PrintNetworkSecurityGroup(frontEndNSG); //============================================================ // Create a network security group for the back end of a subnet // back end subnet contains two rules // - ALLOW-SQL - allows SQL traffic only from the front end subnet // - DENY-WEB - denies all outbound internet traffic from the back end subnet Utilities.Log("Creating a security group for the front end - allows SSH and " + "denies all outbound internet traffic "); var backEndNSG = azure.NetworkSecurityGroups.Define(backEndNSGName) .WithRegion(Region.USEast) .WithExistingResourceGroup(rgName) .DefineRule("ALLOW-SQL") .AllowInbound() .FromAddress("172.16.1.0/24") .FromAnyPort() .ToAnyAddress() .ToPort(1433) .WithProtocol(SecurityRuleProtocol.Tcp) .WithPriority(100) .WithDescription("Allow SQL") .Attach() .DefineRule("DENY-WEB") .DenyOutbound() .FromAnyAddress() .FromAnyPort() .ToAnyAddress() .ToAnyPort() .WithAnyProtocol() .WithDescription("Deny Web") .WithPriority(200) .Attach() .Create(); Utilities.Log("Created a security group for the back end: " + backEndNSG.Id); Utilities.PrintNetworkSecurityGroup(backEndNSG); Utilities.Log("Creating multiple network interfaces"); Utilities.Log("Creating network interface 1"); //======================================================== // Create a network interface and apply the // front end network security group Utilities.Log("Creating a network interface for the front end"); var networkInterface1 = azure.NetworkInterfaces.Define(networkInterfaceName1) .WithRegion(Region.USEast) .WithExistingResourceGroup(rgName) .WithExistingPrimaryNetwork(network) .WithSubnet("Front-end") .WithPrimaryPrivateIPAddressDynamic() .WithNewPrimaryPublicIPAddress(publicIPAddressLeafDNS1) .WithIPForwarding() .WithExistingNetworkSecurityGroup(frontEndNSG) .Create(); Utilities.Log("Created network interface for the front end"); Utilities.PrintNetworkInterface(networkInterface1); //======================================================== // Create a network interface and apply the // back end network security group Utilities.Log("Creating a network interface for the back end"); var networkInterface2 = azure.NetworkInterfaces.Define(networkInterfaceName2) .WithRegion(Region.USEast) .WithExistingResourceGroup(rgName) .WithExistingPrimaryNetwork(network) .WithSubnet("Back-end") .WithPrimaryPrivateIPAddressDynamic() .WithExistingNetworkSecurityGroup(backEndNSG) .Create(); Utilities.PrintNetworkInterface(networkInterface2); //============================================================= // Create a virtual machine (for the front end) // with the network interface that has the network security group for the front end Utilities.Log("Creating a Linux virtual machine (for the front end) - " + "with the network interface that has the network security group for the front end"); var t1 = DateTime.UtcNow; var frontEndVM = azure.VirtualMachines.Define(frontEndVMName) .WithRegion(Region.USEast) .WithExistingResourceGroup(rgName) .WithExistingPrimaryNetworkInterface(networkInterface1) .WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts) .WithRootUsername(UserName) .WithSsh(SshKey) .WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4")) .Create(); var t2 = DateTime.UtcNow; Utilities.Log("Created Linux VM: (took " + (t2 - t1).TotalSeconds + " seconds) " + frontEndVM.Id); // Print virtual machine details Utilities.PrintVirtualMachine(frontEndVM); //============================================================= // Create a virtual machine (for the back end) // with the network interface that has the network security group for the back end Utilities.Log("Creating a Linux virtual machine (for the back end) - " + "with the network interface that has the network security group for the back end"); t1 = DateTime.UtcNow; var backEndVM = azure.VirtualMachines.Define(backEndVMName) .WithRegion(Region.USEast) .WithExistingResourceGroup(rgName) .WithExistingPrimaryNetworkInterface(networkInterface2) .WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts) .WithRootUsername(UserName) .WithSsh(SshKey) .WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4")) .Create(); t2 = DateTime.UtcNow; Utilities.Log("Created a Linux VM: (took " + (t2 - t1).TotalSeconds + " seconds) " + backEndVM.Id); Utilities.PrintVirtualMachine(backEndVM); //======================================================== // List network security groups Utilities.Log("Walking through network security groups"); var networkSecurityGroups = azure.NetworkSecurityGroups.ListByResourceGroup(rgName); foreach (var networkSecurityGroup in networkSecurityGroups) { Utilities.PrintNetworkSecurityGroup(networkSecurityGroup); } //======================================================== // Update a network security group Utilities.Log("Updating the front end network security group to allow FTP"); frontEndNSG.Update() .DefineRule("ALLOW-FTP") .AllowInbound() .FromAnyAddress() .FromAnyPort() .ToAnyAddress() .ToPortRange(20, 21) .WithProtocol(SecurityRuleProtocol.Tcp) .WithDescription("Allow FTP") .WithPriority(200) .Attach() .Apply(); Utilities.Log("Updated the front end network security group"); Utilities.PrintNetworkSecurityGroup(frontEndNSG); } 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 ex) { Utilities.Log(ex); } } }
///GENMHASH:1C505DCDEFCB5F029B7A60E2375286BF:3FA7D2EF04027DEAAE836DB63A20039B internal NicIPConfigurationImpl WithNewPublicIPAddress() { string name = SdkContext.RandomResourceName("pip", 15); return(WithNewPublicIPAddress(PrepareCreatablePublicIP(name, name))); }
///GENMHASH:73C84BBD3D307731A80C2DAF5F9B5EB0:591AFF02B37C91A947B66FA2CFEFFB51 internal NicIPConfigurationImpl WithNewNetwork(string addressSpaceCidr) { return(WithNewNetwork(SdkContext.RandomResourceName("vnet", 20), addressSpaceCidr)); }
public void CanCreateImageFromManagedDisk() { using (var context = FluentMockContext.Start(GetType().FullName)) { var vmName = SdkContext.RandomResourceName("vm7-", 20); var uname = "juser"; var password = "******"; var resourceManager = TestHelper.CreateRollupClient(); var computeManager = TestHelper.CreateComputeManager(); var rgName = TestUtilities.GenerateName("rgfluentchash-"); try { 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 */ .DefineUnmanagedDataDisk("disk1") .WithNewVhd(100) .WithCaching(CachingTypes.ReadWrite) .Attach() .WithNewUnmanagedDataDisk(100) .WithSize(VirtualMachineSizeTypes.StandardDS5V2) .WithNewStorageAccount(SdkContext.RandomResourceName("stg", 17)) .WithOSDiskCaching(CachingTypes.ReadWrite) .Create(); Assert.False(nativeVM.IsManagedDiskEnabled); var osVhdUri = nativeVM.OSUnmanagedDiskVhdUri; Assert.NotNull(osVhdUri); var dataDisks = nativeVM.UnmanagedDataDisks; Assert.Equal(2, dataDisks.Count); computeManager.VirtualMachines.DeleteById(nativeVM.Id); var osDiskName = SdkContext.RandomResourceName("dsk", 15); // Create managed disk with Os from vm's Os disk // var managedOsDisk = computeManager.Disks.Define(osDiskName) .WithRegion(Location) .WithNewResourceGroup(rgName) .WithLinuxFromVhd(osVhdUri) .Create(); // Create managed disk with Data from vm's lun0 data disk // var dataDiskName1 = SdkContext.RandomResourceName("dsk", 15); var vmNativeDataDisk1 = dataDisks[0]; var managedDataDisk1 = computeManager.Disks.Define(dataDiskName1) .WithRegion(Location) .WithNewResourceGroup(rgName) .WithData() .FromVhd(vmNativeDataDisk1.VhdUri) .Create(); // Create managed disk with Data from vm's lun1 data disk // var dataDiskName2 = SdkContext.RandomResourceName("dsk", 15); var vmNativeDataDisk2 = dataDisks[1]; var managedDataDisk2 = computeManager.Disks.Define(dataDiskName2) .WithRegion(Location) .WithNewResourceGroup(rgName) .WithData() .FromVhd(vmNativeDataDisk2.VhdUri) .Create(); // Create an image from the above managed disks // Note that this is not a direct user scenario, but including this as per CRP team request // var imageName = SdkContext.RandomResourceName("img", 15); var customImage = computeManager.VirtualMachineCustomImages.Define(imageName) .WithRegion(Location) .WithNewResourceGroup(rgName) .WithLinuxFromDisk(managedOsDisk, OperatingSystemStateTypes.Generalized) .DefineDataDiskImage() .WithLun(vmNativeDataDisk1.Lun) .FromManagedDisk(managedDataDisk1) .WithDiskCaching(vmNativeDataDisk1.CachingType) .WithDiskSizeInGB(vmNativeDataDisk1.Size + 10) .Attach() .DefineDataDiskImage() .WithLun(vmNativeDataDisk2.Lun) .FromManagedDisk(managedDataDisk2) .WithDiskSizeInGB(vmNativeDataDisk2.Size + 10) .Attach() .Create(); Assert.NotNull(customImage); Assert.Equal(customImage.Name, imageName, ignoreCase: true); Assert.NotNull(customImage.OSDiskImage); Assert.Equal(OperatingSystemStateTypes.Generalized, customImage.OSDiskImage.OsState); Assert.Equal(OperatingSystemTypes.Linux, customImage.OSDiskImage.OsType); Assert.NotNull(customImage.DataDiskImages); Assert.Equal(2, customImage.DataDiskImages.Count); Assert.Equal(customImage.HyperVGeneration, HyperVGenerationTypes.V1); Assert.Null(customImage.SourceVirtualMachineId); Assert.True(customImage.DataDiskImages.ContainsKey(vmNativeDataDisk1.Lun)); Assert.Equal(customImage.DataDiskImages[vmNativeDataDisk1.Lun].Caching, vmNativeDataDisk1.CachingType); Assert.True(customImage.DataDiskImages.ContainsKey(vmNativeDataDisk2.Lun)); Assert.Equal(CachingTypes.None, customImage.DataDiskImages[vmNativeDataDisk2.Lun].Caching); foreach (var vmDisk in dataDisks.Values) { Assert.True(customImage.DataDiskImages.ContainsKey(vmDisk.Lun)); var diskImage = customImage.DataDiskImages[vmDisk.Lun]; Assert.Equal((long)diskImage.DiskSizeGB, vmDisk.Size + 10); Assert.Null(diskImage.BlobUri); Assert.NotNull(diskImage.ManagedDisk); Assert.True(diskImage.ManagedDisk.Id.Equals(managedDataDisk1.Id, StringComparison.OrdinalIgnoreCase) || diskImage.ManagedDisk.Id.Equals(managedDataDisk2.Id, StringComparison.OrdinalIgnoreCase)); } computeManager.Disks.DeleteById(managedOsDisk.Id); computeManager.Disks.DeleteById(managedDataDisk1.Id); computeManager.Disks.DeleteById(managedDataDisk2.Id); computeManager.VirtualMachineCustomImages.DeleteById(customImage.Id); } finally { try { resourceManager.ResourceGroups.DeleteByName(rgName); } catch { } } } }
internal async Task <bool> AddAsync(InstanceName instance, string location, string requiredVersion, string sourceUrl, CancellationToken cancellationToken) { string rgName = instance.ResourceGroupName; logger.WriteVerbose($"Checking if Resource Group {rgName} already exists"); if (!await azure.ResourceGroups.ContainAsync(rgName, cancellationToken)) { if (instance.IsCustom) { logger.WriteError($"Resource group {rgName} is custom and cannot be created."); return(false); } logger.WriteVerbose($"Creating resource group {rgName}"); await azure.ResourceGroups .Define(rgName) .WithRegion(location) .CreateAsync(); logger.WriteInfo($"Resource group {rgName} created."); } // IDEA the template should create a Storage account and/or a Key Vault for Rules' use // TODO https://github.com/gjlumsden/AzureFunctionsSlots suggest that slots must be created in template var resourceName = "aggregator.cli.Instances.instance-template.json"; string armTemplateString; var assembly = Assembly.GetExecutingAssembly(); using (Stream stream = assembly.GetManifestResourceStream(resourceName)) using (StreamReader reader = new StreamReader(stream)) { armTemplateString = await reader.ReadToEndAsync(); } var parsedTemplate = JObject.Parse(armTemplateString); // sanity checks if (parsedTemplate.SelectToken("parameters.appName") == null) { // not good, blah logger.WriteWarning($"Something is wrong with the ARM template"); } string appName = instance.FunctionAppName; var infoVersion = GetCustomAttribute <AssemblyInformationalVersionAttribute>(); var templateParams = new Dictionary <string, Dictionary <string, object> > { { "appName", new Dictionary <string, object> { { "value", appName } } }, { "aggregatorVersion", new Dictionary <string, object> { { "value", infoVersion.InformationalVersion } } }, { "hostingPlanSkuName", new Dictionary <string, object> { { "value", "Y1" } } }, { "hostingPlanSkuTier", new Dictionary <string, object> { { "value", "Dynamic" } } }, }; string deploymentName = SdkContext.RandomResourceName("aggregator", 24); logger.WriteInfo($"Started deployment (id: {deploymentName})"); var deployment = await azure.Deployments.Define(deploymentName) .WithExistingResourceGroup(rgName) .WithTemplate(armTemplateString) .WithParameters(templateParams) .WithMode(DeploymentMode.Incremental) .CreateAsync(cancellationToken); // poll const int pollIntervalInSeconds = 3; int totalDelay = 0; while (!(StringComparer.OrdinalIgnoreCase.Equals(deployment.ProvisioningState, "Succeeded") || StringComparer.OrdinalIgnoreCase.Equals(deployment.ProvisioningState, "Failed") || StringComparer.OrdinalIgnoreCase.Equals(deployment.ProvisioningState, "Cancelled"))) { SdkContext.DelayProvider.Delay(pollIntervalInSeconds * 1000); totalDelay += pollIntervalInSeconds; logger.WriteVerbose($"Deployment running ({totalDelay}s)"); await deployment.RefreshAsync(cancellationToken); } logger.WriteInfo($"Deployment {deployment.ProvisioningState}"); // check runtime package var package = new FunctionRuntimePackage(logger); bool ok = await package.UpdateVersionAsync(requiredVersion, sourceUrl, instance, azure, cancellationToken); if (ok) { var devopsLogonData = DevOpsLogon.Load().connection; if (devopsLogonData.Mode == DevOpsTokenType.PAT) { logger.WriteVerbose($"Saving Azure DevOps token"); ok = await ChangeAppSettingsAsync(instance, devopsLogonData, SaveMode.Default, cancellationToken); if (ok) { logger.WriteInfo($"Azure DevOps token saved"); } else { logger.WriteError($"Failed to save Azure DevOps token"); } } else { logger.WriteWarning($"Azure DevOps token type {devopsLogonData.Mode} is unsupported"); ok = false; } } return(ok); }
public void CanCreateSqlPrivateEndpoint() { using (var context = FluentMockContext.Start(GetType().FullName)) { var dbName = SdkContext.RandomResourceName("cosmosdb", 22); var rgName = SdkContext.RandomResourceName("cosmosdbRg", 22); var networkName = SdkContext.RandomResourceName("network", 22); var subnetName = SdkContext.RandomResourceName("subnet", 22); var plsConnectionName = SdkContext.RandomResourceName("plsconnect", 22); var pedName = SdkContext.RandomResourceName("ped", 22); var region = Region.USWest; var azure = TestHelper.CreateRollupClient(); try { azure.ResourceGroups.Define(rgName) .WithRegion(region) .Create(); var network = azure.Networks.Define(networkName) .WithRegion(region) .WithExistingResourceGroup(rgName) .WithAddressSpace("10.0.0.0/16") .DefineSubnet(subnetName) .WithAddressPrefix("10.0.0.0/24") .WithAccessFromService(ServiceEndpointType.MicrosoftAzureCosmosDB) .Attach() .Create(); network.Subnets[subnetName].Inner.PrivateEndpointNetworkPolicies = "Disabled"; network.Subnets[subnetName].Inner.PrivateLinkServiceNetworkPolicies = "Disabled"; network.Update() .UpdateSubnet(subnetName) .Parent() .Apply(); var databaseAccount = azure.CosmosDBAccounts.Define(dbName) .WithRegion(region) .WithExistingResourceGroup(rgName) .WithDataModelSql() .WithStrongConsistency() .WithDisableKeyBaseMetadataWriteAccess(true) .Create(); Assert.True(databaseAccount.KeyBasedMetadataWriteAccessDisabled); var privateLinkServiceConnection = new PrivateLinkServiceConnectionInner(name: plsConnectionName) { PrivateLinkServiceId = databaseAccount.Id, GroupIds = new List <string> { "Sql" }, PrivateLinkServiceConnectionState = new PrivateLinkServiceConnectionState("Approved"), }; var privateEndpoint = new PrivateEndpointInner(name: pedName) { Location = region.ToString(), Subnet = network.Subnets[subnetName].Inner, PrivateLinkServiceConnections = new List <PrivateLinkServiceConnectionInner> { privateLinkServiceConnection }, }; azure.Networks.Manager.Inner.PrivateEndpoints .CreateOrUpdateWithHttpMessagesAsync(rgName, pedName, privateEndpoint).Wait(); Assert.Equal("Approved", databaseAccount.GetPrivateEndpointConnection(pedName).PrivateLinkServiceConnectionState.Status); databaseAccount.Update() .UpdatePrivateEndpointConnection(pedName) .WithStatus("Rejected") .WithDescription("Rej") .Parent() .Apply(); var connections = databaseAccount.ListPrivateEndpointConnection(); Assert.True(connections.ContainsKey(pedName)); Assert.Equal("Rejected", connections[pedName].PrivateLinkServiceConnectionState.Status); Assert.Equal(1, databaseAccount.ListPrivateLinkResources().Count); } finally { try { azure.ResourceGroups.BeginDeleteByName(rgName); } catch { } } } }
public void UnfinishedTest() { string vnetName1 = SdkContext.RandomResourceName("vnet1", 20); string vnetName2 = SdkContext.RandomResourceName("vnet2", 20); string vnet1FrontEndSubnetName = "frontend"; string vnet1BackEndSubnetName = "backend"; string vnet1FrontEndSubnetNsgName = "frontendnsg"; string vnet1BackEndSubnetNsgName = "backendnsg"; string frontEndVMName = SdkContext.RandomResourceName("fevm", 24); string backEndVMName = SdkContext.RandomResourceName("bevm", 24); string publicIPAddressLeafDNSForFrontEndVM = SdkContext.RandomResourceName("pip1", 24); INetworkManager manager = TestHelper.CreateNetworkManager(); string rgName = SdkContext.RandomResourceName("rgNEMV", 24); try { INetworkSecurityGroup backEndSubnetNsg = manager.NetworkSecurityGroups .Define(vnet1BackEndSubnetNsgName) .WithRegion(Region.USEast) .WithExistingResourceGroup(rgName) .DefineRule("DenyInternetInComing") .DenyInbound() .FromAddress("INTERNET") .FromAnyPort() .ToAnyAddress() .ToAnyPort() .WithAnyProtocol() .Attach() .DefineRule("DenyInternetOutGoing") .DenyOutbound() .FromAnyAddress() .FromAnyPort() .ToAddress("INTERNET") .ToAnyPort() .WithAnyProtocol() .Attach() .Create(); INetwork virtualNetwork1 = manager.Networks .Define(vnetName1) .WithRegion(Region.USEast) .WithExistingResourceGroup(rgName) .WithAddressSpace("192.168.0.0/16") .WithSubnet(vnet1FrontEndSubnetName, "192.168.1.0/24") .DefineSubnet(vnet1BackEndSubnetName) .WithAddressPrefix("192.168.2.0/24") .WithExistingNetworkSecurityGroup(backEndSubnetNsg) .Attach() .Create(); INetworkSecurityGroup frontEndSubnetNsg = manager.NetworkSecurityGroups .Define(vnet1FrontEndSubnetNsgName) .WithRegion(Region.USEast) .WithExistingResourceGroup(rgName) .DefineRule("AllowHttpInComing") .AllowInbound() .FromAddress("INTERNET") .FromAnyPort() .ToAnyAddress() .ToPort(80) .WithProtocol(SecurityRuleProtocol.Tcp) .Attach() .DefineRule("DenyInternetOutGoing") .DenyOutbound() .FromAnyAddress() .FromAnyPort() .ToAddress("INTERNET") .ToAnyPort() .WithAnyProtocol() .Attach() .Create(); virtualNetwork1.Update() .UpdateSubnet(vnet1FrontEndSubnetName) .WithExistingNetworkSecurityGroup(frontEndSubnetNsg) .Parent() .Apply(); INetwork virtualNetwork2 = manager.Networks .Define(vnetName2) .WithRegion(Region.USEast) .WithNewResourceGroup(rgName) .Create(); foreach (INetwork virtualNetwork in manager.Networks.ListByResourceGroup(rgName)) { } manager.Networks.DeleteById(virtualNetwork2.Id); } finally { try { TestHelper.CreateResourceManager().ResourceGroups.DeleteByName(rgName); } catch { } } }
public void CanCRUDSqlContainer() { using (var context = FluentMockContext.Start(GetType().FullName)) { var dbName = SdkContext.RandomResourceName("cosmosdb", 22); var rgName = SdkContext.RandomResourceName("cosmosdbRg", 22); var sqlDbName = SdkContext.RandomResourceName("sqldb", 22); var sqlContainerName = SdkContext.RandomResourceName("sqlcontainer", 22); var region = Region.USWest; var azure = TestHelper.CreateRollupClient(); try { azure.ResourceGroups.Define(rgName).WithRegion(region).Create(); var databaseAccount = azure.CosmosDBAccounts.Define(dbName) .WithRegion(region) .WithExistingResourceGroup(rgName) .WithDataModelSql() .WithStrongConsistency() .WithAutomaticFailoverEnabled(true) .DefineNewSqlDatabase(sqlDbName) .WithThroughput(1000) .DefineNewSqlContainer(sqlContainerName) .WithThroughput(400) .DefineIndexingPolicy() .WithIndexingMode(IndexingMode.Consistent) .WithIncludedPath("/*") .WithExcludedPath("/myPathToNotIndex/*") .WithNewCompositeIndexList() .WithCompositePath("/myOrderByPath1", CompositePathSortOrder.Ascending) .WithCompositePath("/myOrderByPath2", CompositePathSortOrder.Descending) .Attach() .Attach() .WithPartitionKey(PartitionKind.Hash, null) .WithPartitionKeyPath("/myPartitionKey") .WithStoredProcedure("test", "function test(){}") .WithUserDefinedFunction("test", "function test(){}") .WithTrigger("test", "function test(){}", TriggerType.Pre, TriggerOperation.All) .Attach() .Attach() .Create(); Assert.True(databaseAccount.AutomaticFailoverEnabled); var sqldbs = databaseAccount.ListSqlDatabases().ToList(); Assert.Single(sqldbs); var sqldb = sqldbs[0]; Assert.Equal(sqlDbName, sqldb.Name); Assert.Equal(1000, sqldb.GetThroughputSettings().Throughput); var containers = sqldb.ListSqlContainers().ToList(); Assert.Single(containers); var container = containers[0]; Assert.Equal(sqlContainerName, container.Name); Assert.Equal(400, container.GetThroughputSettings().Throughput); Assert.Equal(IndexingMode.Consistent, container.IndexingPolicy.IndexingMode); Assert.NotNull(container.IndexingPolicy.IncludedPaths.Single(element => element.Path == "/*")); Assert.NotNull(container.IndexingPolicy.ExcludedPaths.Single(element => element.Path == "/myPathToNotIndex/*")); Assert.Equal(1, container.IndexingPolicy.CompositeIndexes.Count); Assert.Equal(2, container.IndexingPolicy.CompositeIndexes[0].Count); Assert.True(container.PartitionKey.Paths.Contains("/myPartitionKey")); Assert.Equal(PartitionKind.Hash, container.PartitionKey.Kind); Assert.NotNull(container.GetStoredProcedure("test")); Assert.NotNull(container.GetUserDefinedFunction("test")); Assert.NotNull(container.GetTrigger("test")); databaseAccount = databaseAccount.Update() .WithAutomaticFailoverEnabled(false) .UpdateSqlDatabase(sqlDbName) .WithThroughput(800) .UpdateSqlContainer(sqlContainerName) .WithThroughput(600) .UpdateIndexingPolicy() .WithoutExcludedPath("/myPathToNotIndex/*") .Parent() .Parent() .Parent() .Apply(); Assert.False(databaseAccount.AutomaticFailoverEnabled); sqldb = databaseAccount.GetSqlDatabase(sqlDbName); Assert.Equal(800, sqldb.GetThroughputSettings().Throughput); container = sqldb.GetSqlContainer(sqlContainerName); Assert.Equal(600, container.GetThroughputSettings().Throughput); Assert.Null(container.IndexingPolicy.ExcludedPaths.SingleOrDefault(element => element.Path == "/myPathToNotIndex/*")); } finally { try { azure.ResourceGroups.BeginDeleteByName(rgName); } catch { } } } }
/** * Azure Service Bus basic scenario sample. * - Create namespace. * - Create a service bus subscription in the topic with session and dead-letter enabled. * - Create another subscription in the topic with auto deletion of idle entities. * - Create second topic with new Send Authorization rule, partitioning enabled and a new Service bus Subscription. * - Update second topic to change time for AutoDeleteOnIdle time, without Send rule and with a new manage authorization rule. * - Get the keys from default authorization rule to connect to topic. * - Send a "Hello" message to topic using Data plan sdk for Service Bus. * - Delete a topic * - Delete namespace */ public static void RunSample(IAzure azure) { var rgName = SdkContext.RandomResourceName("rgSB04_", 24); var namespaceName = SdkContext.RandomResourceName("namespace", 20); var topic1Name = SdkContext.RandomResourceName("topic1_", 24); var topic2Name = SdkContext.RandomResourceName("topic2_", 24); var subscription1Name = SdkContext.RandomResourceName("subs_", 24); var subscription2Name = SdkContext.RandomResourceName("subs_", 24); var subscription3Name = SdkContext.RandomResourceName("subs_", 24); var sendRuleName = "SendRule"; var manageRuleName = "ManageRule"; try { //============================================================ // Create a namespace. Utilities.Log("Creating name space " + namespaceName + " in resource group " + rgName + "..."); var serviceBusNamespace = azure.ServiceBusNamespaces .Define(namespaceName) .WithRegion(Region.USWest) .WithNewResourceGroup(rgName) .WithSku(NamespaceSku.PremiumCapacity1) .WithNewTopic(topic1Name, 1024) .Create(); Utilities.Log("Created service bus " + serviceBusNamespace.Name); Utilities.Print(serviceBusNamespace); Utilities.Log("Created topic following topic along with namespace " + namespaceName); var firstTopic = serviceBusNamespace.Topics.GetByName(topic1Name); Utilities.Print(firstTopic); //============================================================ // Create a service bus subscription in the topic with session and dead-letter enabled. Utilities.Log("Creating subscription " + subscription1Name + " in topic " + topic1Name + "..."); var firstSubscription = firstTopic.Subscriptions.Define(subscription1Name) .WithSession() .WithDefaultMessageTTL(TimeSpan.FromMinutes(20)) .WithMessageMovedToDeadLetterSubscriptionOnMaxDeliveryCount(20) .WithExpiredMessageMovedToDeadLetterSubscription() .WithMessageMovedToDeadLetterSubscriptionOnFilterEvaluationException() .Create(); Utilities.Log("Created subscription " + subscription1Name + " in topic " + topic1Name + "..."); Utilities.Print(firstSubscription); //============================================================ // Create another subscription in the topic with auto deletion of idle entities. Utilities.Log("Creating another subscription " + subscription2Name + " in topic " + topic1Name + "..."); var secondSubscription = firstTopic.Subscriptions.Define(subscription2Name) .WithSession() .WithDeleteOnIdleDurationInMinutes(20) .Create(); Utilities.Log("Created subscription " + subscription2Name + " in topic " + topic1Name + "..."); Utilities.Print(secondSubscription); //============================================================ // Create second topic with new Send Authorization rule, partitioning enabled and a new Service bus Subscription. Utilities.Log("Creating second topic " + topic2Name + ", with De-duplication and AutoDeleteOnIdle features..."); var secondTopic = serviceBusNamespace.Topics.Define(topic2Name) .WithNewSendRule(sendRuleName) .WithPartitioning() .WithNewSubscription(subscription3Name) .Create(); Utilities.Log("Created second topic in namespace"); Utilities.Print(secondTopic); Utilities.Log("Creating following authorization rules in second topic "); var authorizationRules = secondTopic.AuthorizationRules.List(); foreach (var authorizationRule in authorizationRules) { Utilities.Print(authorizationRule); } //============================================================ // Update second topic to change time for AutoDeleteOnIdle time, without Send rule and with a new manage authorization rule. Utilities.Log("Updating second topic " + topic2Name + "..."); secondTopic = secondTopic.Update() .WithDeleteOnIdleDurationInMinutes(5) .WithoutAuthorizationRule(sendRuleName) .WithNewManageRule(manageRuleName) .Apply(); Utilities.Log("Updated second topic to change its auto deletion time"); Utilities.Print(secondTopic); Utilities.Log("Updated following authorization rules in second topic, new list of authorization rules are "); authorizationRules = secondTopic.AuthorizationRules.List(); foreach (var authorizationRule in authorizationRules) { Utilities.Print(authorizationRule); } //============================================================= // Get connection string for default authorization rule of namespace var namespaceAuthorizationRules = serviceBusNamespace.AuthorizationRules.List(); Utilities.Log("Number of authorization rule for namespace :" + namespaceAuthorizationRules.Count()); foreach (var namespaceAuthorizationRule in namespaceAuthorizationRules) { Utilities.Print(namespaceAuthorizationRule); } Utilities.Log("Getting keys for authorization rule ..."); var keys = namespaceAuthorizationRules.FirstOrDefault().GetKeys(); Utilities.Print(keys); //============================================================= // Send a message to topic. Utilities.SendMessageToTopic(keys.PrimaryConnectionString, topic1Name, "Hello"); //============================================================= // Delete a topic and namespace Utilities.Log("Deleting topic " + topic1Name + "in namespace " + namespaceName + "..."); serviceBusNamespace.Topics.DeleteByName(topic1Name); Utilities.Log("Deleted topic " + topic1Name + "..."); Utilities.Log("Deleting namespace " + namespaceName + "..."); // This will delete the namespace and topic within it. try { azure.ServiceBusNamespaces.DeleteById(serviceBusNamespace.Id); } catch (Exception) { } Utilities.Log("Deleted namespace " + namespaceName + "..."); } finally { try { Utilities.Log("Deleting Resource Group: " + rgName); azure.ResourceGroups.BeginDeleteByName(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); } } }
/** * This sample shows examples of retrieving metrics and activity logs for Storage Account. * - List all metric definitions available for a storage account * - Retrieve and show metrics for the past 7 days for Transactions where * - Api name was 'PutBlob' and * - response type was 'Success' and * - Geo type was 'Primary' * - Retrieve and show all activity logs for the past 7 days for the same Storage account. */ public static void RunSample(IAzure azure) { string storageAccountName = SdkContext.RandomResourceName("saMonitor", 15); string rgName = SdkContext.RandomResourceName("rgMonitor", 15); try { // ============================================================ // Create a storage account Utilities.Log("Creating a Storage Account"); var storageAccount = azure.StorageAccounts.Define(storageAccountName) .WithRegion(Region.USEast) .WithNewResourceGroup(rgName) .WithBlobStorageAccountKind() .WithAccessTier(AccessTier.Cool) .Create(); Utilities.Log("Created a Storage Account:"); Utilities.PrintStorageAccount(storageAccount); var storageAccountKeys = storageAccount.GetKeys(); var storageConnectionString = $"DefaultEndpointsProtocol=http;AccountName={storageAccount.Name};AccountKey={storageAccountKeys.First().Value}"; // Add some blob transaction events AddBlobTransactions(storageConnectionString); DateTime recordDateTime = DateTime.Now; // get metric definitions for storage account. foreach (var metricDefinition in azure.MetricDefinitions.ListByResource(storageAccount.Id)) { // find metric definition for Transactions if (metricDefinition.Name.LocalizedValue.Equals("transactions", StringComparison.OrdinalIgnoreCase)) { // get metric records var metricCollection = metricDefinition.DefineQuery() .StartingFrom(recordDateTime.AddDays(-7)) .EndsBefore(recordDateTime) .WithAggregation("Average") .WithInterval(TimeSpan.FromMinutes(5)) .WithOdataFilter("apiName eq 'PutBlob' and responseType eq 'Success' and geoType eq 'Primary'") .Execute(); Utilities.Log("Metrics for '" + storageAccount.Id + "':"); Utilities.Log("Query time: " + metricCollection.Timespan); Utilities.Log("Time Grain: " + metricCollection.Interval); Utilities.Log("Cost: " + metricCollection.Cost); foreach (var metric in metricCollection.Metrics) { Utilities.Log("\tMetric: " + metric.Name.LocalizedValue); Utilities.Log("\tType: " + metric.Type); Utilities.Log("\tUnit: " + metric.Unit); Utilities.Log("\tTime Series: "); foreach (var timeElement in metric.Timeseries) { Utilities.Log("\t\tMetadata: "); foreach (var metadata in timeElement.Metadatavalues) { Utilities.Log("\t\t\t" + metadata.Name.LocalizedValue + ": " + metadata.Value); } Utilities.Log("\t\tData: "); foreach (var data in timeElement.Data) { Utilities.Log("\t\t\t" + data.TimeStamp + " : (Min) " + data.Minimum + " : (Max) " + data.Maximum + " : (Avg) " + data.Average + " : (Total) " + data.Total + " : (Count) " + data.Count); } } } break; } } // get activity logs for the same period. var logs = azure.ActivityLogs.DefineQuery() .StartingFrom(recordDateTime.AddDays(-7)) .EndsBefore(recordDateTime) .WithAllPropertiesInResponse() .FilterByResource(storageAccount.Id) .Execute(); Utilities.Log("Activity logs for the Storage Account:"); foreach (var eventData in logs) { Utilities.Log("\tEvent: " + eventData.EventName?.LocalizedValue); Utilities.Log("\tOperation: " + eventData.OperationName?.LocalizedValue); Utilities.Log("\tCaller: " + eventData.Caller); Utilities.Log("\tCorrelationId: " + eventData.CorrelationId); Utilities.Log("\tSubscriptionId: " + eventData.SubscriptionId); } } finally { if (azure.ResourceGroups.GetByName(rgName) != null) { Utilities.Log("Deleting Resource Group: " + rgName); azure.ResourceGroups.BeginDeleteByName(rgName); Utilities.Log("Deleted Resource Group: " + rgName); } else { Utilities.Log("Did not create any resources in Azure. No clean up is necessary"); } } }