public static void RunSample(IAzure azure)
{
string resourceGroupName = SdkContext.RandomResourceName("rgNEMV_", 24);
string app1Name = SdkContext.RandomResourceName("webapp1-", 20);
string app2Name = SdkContext.RandomResourceName("webapp2-", 20);
string app3Name = SdkContext.RandomResourceName("webapp3-", 20);
string app4Name = SdkContext.RandomResourceName("webapp4-", 20);
string app5Name = SdkContext.RandomResourceName("webapp5-", 20);
string plan1Name = SdkContext.RandomResourceName("jplan1_", 15);
string plan2Name = SdkContext.RandomResourceName("jplan2_", 15);
string plan3Name = SdkContext.RandomResourceName("jplan3_", 15);
string domainName = SdkContext.RandomResourceName("jsdkdemo-", 20) + ".com";
string trafficManagerName = SdkContext.RandomResourceName("jsdktm-", 20);
try
{
//============================================================
// Purchase a domain (will be canceled for a full refund)
Utilities.Log("Purchasing a domain " + domainName + "...");
azure.ResourceGroups.Define(resourceGroupName)
.WithRegion(Region.USEast2)
.Create();
var domain = azure.AppServices.AppServiceDomains.Define(domainName)
.WithExistingResourceGroup(resourceGroupName)
.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);
//============================================================
// Create a self-singed SSL certificate
pfxPath = "webapp_" + nameof(ManageLinuxWebAppWithTrafficManager).ToLower() + ".pfx";
Utilities.Log("Creating a self-signed certificate " + pfxPath + "...");
Utilities.CreateCertificate(domainName, pfxPath, CERT_PASSWORD);
//============================================================
// Create 3 app service plans in 3 regions
Utilities.Log("Creating app service plan " + plan1Name + " in US West...");
var plan1 = CreateAppServicePlan(azure, resourceGroupName, plan1Name, Region.USNorthCentral);
Utilities.Log("Created app service plan " + plan1.Name);
Utilities.Print(plan1);
Utilities.Log("Creating app service plan " + plan2Name + " in Europe West...");
var plan2 = CreateAppServicePlan(azure, resourceGroupName, plan2Name, Region.EuropeWest);
Utilities.Log("Created app service plan " + plan2.Name);
Utilities.Print(plan1);
Utilities.Log("Creating app service plan " + plan3Name + " in Asia South East...");
var plan3 = CreateAppServicePlan(azure, resourceGroupName, plan3Name, Region.AsiaSouthEast);
Utilities.Log("Created app service plan " + plan2.Name);
Utilities.Print(plan1);
//============================================================
// Create 5 web apps under these 3 app service plans
Utilities.Log("Creating web app " + app1Name + "...");
var app1 = CreateWebApp(azure, domain, resourceGroupName, app1Name, plan1);
Utilities.Log("Created web app " + app1.Name);
Utilities.Print(app1);
Utilities.Log("Creating another web app " + app2Name + "...");
var app2 = CreateWebApp(azure, domain, resourceGroupName, app2Name, plan2);
Utilities.Log("Created web app " + app2.Name);
Utilities.Print(app2);
Utilities.Log("Creating another web app " + app3Name + "...");
var app3 = CreateWebApp(azure, domain, resourceGroupName, app3Name, plan3);
Utilities.Log("Created web app " + app3.Name);
Utilities.Print(app3);
Utilities.Log("Creating another web app " + app3Name + "...");
var app4 = CreateWebApp(azure, domain, resourceGroupName, app4Name, plan1);
Utilities.Log("Created web app " + app4.Name);
Utilities.Print(app4);
Utilities.Log("Creating another web app " + app3Name + "...");
var app5 = CreateWebApp(azure, domain, resourceGroupName, app5Name, plan1);
Utilities.Log("Created web app " + app5.Name);
Utilities.Print(app5);
//============================================================
// Create a traffic manager
Utilities.Log("Creating a traffic manager " + trafficManagerName + " for the web apps...");
var trafficManager = azure.TrafficManagerProfiles
.Define(trafficManagerName)
.WithExistingResourceGroup(resourceGroupName)
.WithLeafDomainLabel(trafficManagerName)
.WithTrafficRoutingMethod(TrafficRoutingMethod.Weighted)
.DefineAzureTargetEndpoint("endpoint1")
.ToResourceId(app1.Id)
.Attach()
.DefineAzureTargetEndpoint("endpoint2")
.ToResourceId(app2.Id)
.Attach()
.DefineAzureTargetEndpoint("endpoint3")
.ToResourceId(app3.Id)
.Attach()
.Create();
Utilities.Log("Created traffic manager " + trafficManager.Name);
//============================================================
// Scale up the app service plans
Utilities.Log("Scaling up app service plan " + plan1Name + "...");
plan1.Update()
.WithCapacity(plan1.Capacity * 2)
.Apply();
Utilities.Log("Scaled up app service plan " + plan1Name);
Utilities.Print(plan1);
Utilities.Log("Scaling up app service plan " + plan2Name + "...");
plan2.Update()
.WithCapacity(plan2.Capacity * 2)
.Apply();
Utilities.Log("Scaled up app service plan " + plan2Name);
Utilities.Print(plan2);
Utilities.Log("Scaling up app service plan " + plan3Name + "...");
plan3.Update()
.WithCapacity(plan3.Capacity * 2)
.Apply();
Utilities.Log("Scaled up app service plan " + plan3Name);
Utilities.Print(plan3);
}
finally
{
try
{
Utilities.Log("Deleting Resource Group: " + resourceGroupName);
azure.ResourceGroups.DeleteByName(resourceGroupName);
Utilities.Log("Deleted Resource Group: " + resourceGroupName);
}
catch (NullReferenceException)
{
Utilities.Log("Did not create any resources in Azure. No clean up is necessary");
}
catch (Exception g)
{
Utilities.Log(g);
}
}
}
/**
* Azure Compute sample for managing virtual machines -
* - Create N virtual machines in parallel
*/
public static void RunSample(IAzure azure)
{
string rgName = SdkContext.RandomResourceName("rgCOPP", 24);
string networkName = SdkContext.RandomResourceName("vnetCOMV", 24);
string storageAccountName = SdkContext.RandomResourceName("stgCOMV", 20);
try
{
// Create a resource group [Where all resources gets created]
IResourceGroup resourceGroup = azure.ResourceGroups
.Define(rgName)
.WithRegion(Region.USEast)
.Create();
// Prepare Creatable Network definition [Where all the virtual machines get added to]
var creatableNetwork = azure.Networks
.Define(networkName)
.WithRegion(Region.USEast)
.WithExistingResourceGroup(resourceGroup)
.WithAddressSpace("172.16.0.0/16");
// Prepare Creatable Storage account definition [For storing VMs disk]
var creatableStorageAccount = azure.StorageAccounts
.Define(storageAccountName)
.WithRegion(Region.USEast)
.WithExistingResourceGroup(resourceGroup);
// Prepare a batch of Creatable Virtual Machines definitions
List <ICreatable <IVirtualMachine> > creatableVirtualMachines = new List <ICreatable <IVirtualMachine> >();
for (int i = 0; i < vmCount; i++)
{
var creatableVirtualMachine = azure.VirtualMachines
.Define("VM-" + i)
.WithRegion(Region.USEast)
.WithExistingResourceGroup(resourceGroup)
.WithNewPrimaryNetwork(creatableNetwork)
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername("tirekicker")
.WithRootPassword("12NewPA$$w0rd!")
.WithSize(VirtualMachineSizeTypes.StandardD3V2)
.WithNewStorageAccount(creatableStorageAccount);
creatableVirtualMachines.Add(creatableVirtualMachine);
}
var startTime = DateTimeOffset.Now.UtcDateTime;
Utilities.Log("Creating the virtual machines");
Utilities.Log("Created virtual machines");
var virtualMachines = azure.VirtualMachines.Create(creatableVirtualMachines.ToArray());
foreach (var virtualMachine in virtualMachines)
{
Utilities.Log(virtualMachine.Id);
}
var endTime = DateTimeOffset.Now.UtcDateTime;
Utilities.Log($"Created VM: took {(endTime - startTime).TotalSeconds} seconds");
}
finally
{
Utilities.Log($"Deleting resource group : {rgName}");
azure.ResourceGroups.DeleteByName(rgName);
Utilities.Log($"Deleted resource group : {rgName}");
}
}
/**
* Azure DocumentDB sample -
* - Create a DocumentDB configured with a single read location
* - Get the credentials for the DocumentDB
* - Update the DocumentDB with additional read locations
* - add collection to the DocumentDB with throughput 4000
* - Delete the DocumentDB
*/
public static void RunSample(IAzure azure)
{
string docDBName = SdkContext.RandomResourceName("docDb", 10);
string rgName = SdkContext.RandomResourceName("rgNEMV", 24);
try
{
//============================================================
// Create a DocumentDB.
Console.WriteLine("Creating a DocumentDB...");
IDocumentDBAccount documentDBAccount = azure.DocumentDBAccounts.Define(docDBName)
.WithRegion(Region.USWest)
.WithNewResourceGroup(rgName)
.WithKind(DatabaseAccountKind.GlobalDocumentDB)
.WithSessionConsistency()
.WithWriteReplication(Region.USEast)
.WithReadReplication(Region.USCentral)
.WithIpRangeFilter("13.91.6.132,13.91.6.1/24")
.Create();
Console.WriteLine("Created DocumentDB");
Utilities.Print(documentDBAccount);
//============================================================
// Update document db with three additional read regions
Console.WriteLine("Updating DocumentDB with three additional read replication regions");
documentDBAccount = documentDBAccount.Update()
.WithReadReplication(Region.AsiaEast)
.WithReadReplication(Region.AsiaSouthEast)
.WithReadReplication(Region.UKSouth)
.Apply();
Console.WriteLine("Updated DocumentDB");
Utilities.Print(documentDBAccount);
//============================================================
// Get credentials for the DocumentDB.
Console.WriteLine("Get credentials for the DocumentDB");
DatabaseAccountListKeysResultInner databaseAccountListKeysResult = documentDBAccount.ListKeys();
string masterKey = databaseAccountListKeysResult.PrimaryMasterKey;
string endPoint = documentDBAccount.DocumentEndpoint;
//============================================================
// Connect to DocumentDB and add a collection
Console.WriteLine("Connecting and adding collection");
//CreateDBAndAddCollection(masterKey, endPoint);
//============================================================
// Delete DocumentDB
Console.WriteLine("Deleting the DocumentDB");
azure.DocumentDBAccounts.DeleteById(documentDBAccount.Id);
Console.WriteLine("Deleted the DocumentDB");
}
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 e)
{
Utilities.Log(e.StackTrace);
}
}
}
public void CanCreateUpdateVirtualMachineWithEmptyManagedDataDisks()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var publicIPDnsLabel = SdkContext.RandomResourceName("pip", 20);
var uname = "juser";
var password = "******";
// Create with implicit + explicit empty disks, check default and override
//
var vmName1 = "myvm1";
var explicitlyCreatedEmptyDiskName1 = SdkContext.RandomResourceName(vmName1 + "_mdisk_", 25);
var explicitlyCreatedEmptyDiskName2 = SdkContext.RandomResourceName(vmName1 + "_mdisk_", 25);
var explicitlyCreatedEmptyDiskName3 = SdkContext.RandomResourceName(vmName1 + "_mdisk_", 25);
var resourceManager = TestHelper.CreateRollupClient();
var computeManager = TestHelper.CreateComputeManager();
var rgName = TestUtilities.GenerateName("rgfluentchash-");
try
{
var resourceGroup = resourceManager.ResourceGroups
.Define(rgName)
.WithRegion(Location)
.Create();
var creatableEmptyDisk1 = computeManager.Disks
.Define(explicitlyCreatedEmptyDiskName1)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithData()
.WithSizeInGB(150);
var creatableEmptyDisk2 = computeManager.Disks
.Define(explicitlyCreatedEmptyDiskName2)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithData()
.WithSizeInGB(150);
var creatableEmptyDisk3 = computeManager.Disks
.Define(explicitlyCreatedEmptyDiskName3)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithData()
.WithSizeInGB(150);
var virtualMachine = computeManager.VirtualMachines
.Define(vmName1)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithNewPrimaryPublicIPAddress(publicIPDnsLabel)
.WithPopularLinuxImage(LinuxImage)
.WithRootUsername(uname)
.WithRootPassword(password)
// Start: Add 5 empty managed disks
.WithNewDataDisk(100) // CreateOption: EMPTY
.WithNewDataDisk(100, 1, CachingTypes.ReadOnly) // CreateOption: EMPTY
.WithNewDataDisk(creatableEmptyDisk1) // CreateOption: ATTACH
.WithNewDataDisk(creatableEmptyDisk2, 2, CachingTypes.None) // CreateOption: ATTACH
.WithNewDataDisk(creatableEmptyDisk3, 3, CachingTypes.None) // CreateOption: ATTACH
// End : Add 5 empty managed disks
.WithSize(VirtualMachineSizeTypes.StandardD5V2)
.WithOSDiskCaching(CachingTypes.ReadWrite)
.Create();
Assert.True(virtualMachine.IsManagedDiskEnabled);
// There should not be any un-managed data disks
//
Assert.NotNull(virtualMachine.UnmanagedDataDisks);
Assert.Equal(0, virtualMachine.UnmanagedDataDisks.Count);
// Validate the managed data disks
//
var dataDisks = virtualMachine.DataDisks;
Assert.NotNull(dataDisks);
Assert.True(dataDisks.Count == 5);
Assert.True(dataDisks.ContainsKey(1));
var dataDiskLun1 = dataDisks[1];
Assert.NotNull(dataDiskLun1.Id);
Assert.Equal(CachingTypes.ReadOnly, dataDiskLun1.CachingType);
Assert.Equal(100, dataDiskLun1.Size);
Assert.True(dataDisks.ContainsKey(2));
var dataDiskLun2 = dataDisks[2];
Assert.NotNull(dataDiskLun2.Id);
Assert.Equal(CachingTypes.None, dataDiskLun2.CachingType);
Assert.Equal(150, dataDiskLun2.Size);
Assert.True(dataDisks.ContainsKey(3));
var dataDiskLun3 = dataDisks[3];
Assert.NotNull(dataDiskLun3.Id);
Assert.Equal(CachingTypes.None, dataDiskLun3.CachingType);
Assert.Equal(150, dataDiskLun3.Size);
// Validate the defaults assigned
//
foreach (var dataDisk in dataDisks.Values)
{
if (dataDisk.Lun != 1 && dataDisk.Lun != 2 && dataDisk.Lun != 3)
{
Assert.Equal(CachingTypes.ReadWrite, dataDisk.CachingType);
Assert.Equal(StorageAccountTypes.StandardLRS, dataDisk.StorageAccountType);
}
}
// Updating and adding disk as part of VM Update seems consistency failing, CRP is aware of
// this, hence until it is fixed comment-out the test
//
// {
// "startTime": "2017-01-26T05:48:59.9290573+00:00",
// "endTime": "2017-01-26T05:49:02.2884052+00:00",
// "status": "Failed",
// "error": {
// "code": "InternalExecutionError",
// "message": "An internal execution error occurred."
// },
// "name": "bc8072a7-38bb-445b-ae59-f16cf125342c"
// }
//
// virtualMachine.Deallocate();
//
// virtualMachine.Update()
// .WithDataDiskUpdated(1, 200)
// .WithDataDiskUpdated(2, 200, CachingTypes.ReadWrite)
// .WithNewDataDisk(60)
// .Apply();
//
// Assert.True(virtualMachine.IsManagedDiskEnabled());
// // There should not be any un-managed data disks
// //
// Assert.NotNull(virtualMachine.UnmanagedDataDisks());
// Assert.Equal(virtualMachine.UnmanagedDataDisks().Count, 0);
//
// // Validate the managed data disks
// //
// dataDisks = virtualMachine.DataDisks;
// Assert.NotNull(dataDisks);
// Assert.True(dataDisks.Count == 6);
// Assert.True(dataDisks.ContainsKey(1));
// dataDiskLun1 = dataDisks[1];
// Assert.NotNull(dataDiskLun1.Id);
// Assert.Equal(dataDiskLun1.CachingType(), CachingTypes.ReadOnly);
// Assert.Equal(dataDiskLun1.Count, 200); // 100 -> 200
//
// Assert.True(dataDisks.ContainsKey(2));
// dataDiskLun2 = dataDisks[2];
// Assert.NotNull(dataDiskLun2.Id);
// Assert.Equal(dataDiskLun2.CachingType(), CachingTypes.ReadWrite); // None -> ReadWrite
// Assert.Equal(dataDiskLun2.Count, 200); // 150 -> 200
//
// Assert.True(dataDisks.ContainsKey(3));
// dataDiskLun3 = dataDisks[3];
// Assert.NotNull(dataDiskLun3.Id);
// Assert.Equal(dataDiskLun3.CachingType(), CachingTypes.None);
// Assert.Equal(dataDiskLun3.Count, 150);
//
// // Ensure defaults of other disks are not affected
// foreach (VirtualMachineDataDisk dataDisk in dataDisks.Values()) {
// if (dataDisk.Lun != 1 && dataDisk.Lun != 3) {
// Assert.Equal(dataDisk.CachingType(), CachingTypes.ReadWrite);
// Assert.Equal(dataDisk.StorageAccountType(), StorageAccountTypes.STANDARD_LRS);
// }
// }
}
finally
{
try
{
resourceManager.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
public void CreateUpdate()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
string groupName = SdkContext.RandomResourceName("rg", 10);
string clusterName = SdkContext.RandomResourceName("cluster", 15);
string saName = SdkContext.RandomResourceName("sa", 15);
string shareName = "myfileshare";
string shareMountPath = "azurefileshare";
string blobFileSystemPath = "myblobsystem";
string containerName = "mycontainer";
string userName = "******";
string storageAccountKey = "dummy_key";
string fileShareUri = "dummy_uri";
var manager = TestHelper.CreateBatchAIManager();
IBatchAICluster cluster = manager.BatchAIClusters.Define(clusterName)
.WithRegion(REGION)
.WithNewResourceGroup(groupName)
.WithVMSize(VirtualMachineSizeTypes.StandardD1V2.Value)
.WithUserName(userName)
.WithPassword("MyPassword")
.WithAutoScale(1, 1)
.WithLowPriority()
.DefineSetupTask()
.WithCommandLine("echo Hello World!")
.WithStdOutErrPath("./outputpath")
.Attach()
.DefineAzureFileShare()
.WithStorageAccountName(saName)
.WithAzureFileUrl(fileShareUri)
.WithRelativeMountPath(shareMountPath)
.WithAccountKey(storageAccountKey)
.Attach()
.DefineAzureBlobFileSystem()
.WithStorageAccountName(saName)
.WithContainerName(containerName)
.WithRelativeMountPath(blobFileSystemPath)
.WithAccountKey(storageAccountKey)
.Attach()
.WithTag("tag1", "value1")
.Create();
Assert.Equal(AllocationState.Steady, cluster.AllocationState);
Assert.Equal(userName, cluster.AdminUserName);
Assert.Equal(VmPriority.Lowpriority, cluster.VMPriority);
Assert.Equal(1, cluster.NodeSetup.MountVolumes.AzureFileShares.Count);
Assert.Equal(shareMountPath, cluster.NodeSetup.MountVolumes.AzureFileShares.ElementAt(0).RelativeMountPath);
Assert.Equal(1, cluster.NodeSetup.MountVolumes.AzureBlobFileSystems.Count);
Assert.Equal(blobFileSystemPath, cluster.NodeSetup.MountVolumes.AzureBlobFileSystems.ElementAt(0).RelativeMountPath);
cluster.Update()
.WithAutoScale(1, 2, 2)
.WithTag("tag1", "value2")
.Apply();
Assert.Equal(2, cluster.ScaleSettings.AutoScale.MaximumNodeCount);
string tag1;
Assert.True(cluster.Tags.TryGetValue("tag1", out tag1));
Assert.Equal("value2", tag1);
manager.ResourceManager.ResourceGroups.DeleteByName(groupName);
}
}
public void CanCreateVirtualMachineFromPIRImageWithManagedOsDisk()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var vmName1 = "myvm1";
var publicIPDnsLabel = SdkContext.RandomResourceName("pip", 20);
var uname = "juser";
var password = "******";
var resourceManager = TestHelper.CreateRollupClient();
var computeManager = TestHelper.CreateComputeManager();
var rgName = TestUtilities.GenerateName("rgfluentchash-");
try
{
var virtualMachine = computeManager.VirtualMachines
.Define(vmName1)
.WithRegion(Location)
.WithNewResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithNewPrimaryPublicIPAddress(publicIPDnsLabel)
.WithPopularLinuxImage(LinuxImage)
.WithRootUsername(uname)
.WithRootPassword(password)
.WithSize(VirtualMachineSizeTypes.StandardD5V2)
.WithOSDiskCaching(CachingTypes.ReadWrite)
.Create();
// Ensure default to managed disk
//
Assert.True(virtualMachine.IsManagedDiskEnabled);
// Validate caching, size and the default storage account type set for the managed disk
// backing os disk
//
Assert.NotNull(virtualMachine.OSDiskStorageAccountType);
Assert.Equal(CachingTypes.ReadWrite, virtualMachine.OSDiskCachingType);
Assert.Equal(virtualMachine.Size, VirtualMachineSizeTypes.StandardD5V2);
// Validate the implicit managed disk created by CRP to back the os disk
//
Assert.NotNull(virtualMachine.OSDiskId);
var osDisk = computeManager.Disks.GetById(virtualMachine.OSDiskId);
Assert.True(osDisk.IsAttachedToVirtualMachine);
Assert.Equal(OperatingSystemTypes.Linux, osDisk.OSType);
// Check the auto created public ip
//
var publicIPId = virtualMachine.GetPrimaryPublicIPAddressId();
Assert.NotNull(publicIPId);
// Validates the options which are valid only for native disks
//
Assert.Null(virtualMachine.OSUnmanagedDiskVhdUri);
Assert.NotNull(virtualMachine.UnmanagedDataDisks);
Assert.True(virtualMachine.UnmanagedDataDisks.Count == 0);
}
finally
{
try
{
resourceManager.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
public void CanUpdateVirtualMachineByAddingAndRemovingManagedDisks()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var publicIPDnsLabel = SdkContext.RandomResourceName("pip", 20);
var uname = "juser";
var password = "******";
// Create with implicit + explicit empty disks, check default and override
//
var vmName1 = "myvm1";
var explicitlyCreatedEmptyDiskName1 = SdkContext.RandomResourceName(vmName1 + "_mdisk_", 25);
var explicitlyCreatedEmptyDiskName2 = SdkContext.RandomResourceName(vmName1 + "_mdisk_", 25);
var explicitlyCreatedEmptyDiskName3 = SdkContext.RandomResourceName(vmName1 + "_mdisk_", 25);
var resourceManager = TestHelper.CreateRollupClient();
var computeManager = TestHelper.CreateComputeManager();
var rgName = TestUtilities.GenerateName("rgfluentchash-");
try
{
var resourceGroup = resourceManager.ResourceGroups
.Define(rgName)
.WithRegion(Location)
.Create();
var creatableEmptyDisk1 = computeManager.Disks
.Define(explicitlyCreatedEmptyDiskName1)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithData()
.WithSizeInGB(150);
var creatableEmptyDisk2 = computeManager.Disks
.Define(explicitlyCreatedEmptyDiskName2)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithData()
.WithSizeInGB(150);
var creatableEmptyDisk3 = computeManager.Disks
.Define(explicitlyCreatedEmptyDiskName3)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithData()
.WithSizeInGB(150);
var virtualMachine1 = computeManager.VirtualMachines
.Define(vmName1)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithNewPrimaryPublicIPAddress(publicIPDnsLabel)
.WithPopularLinuxImage(LinuxImage)
.WithRootUsername(uname)
.WithRootPassword(password)
// Start: Add bunch of empty managed disks
.WithNewDataDisk(100) // CreateOption: EMPTY
.WithNewDataDisk(100, 1, CachingTypes.ReadWrite) // CreateOption: EMPTY
.WithNewDataDisk(creatableEmptyDisk1) // CreateOption: ATTACH
.WithNewDataDisk(creatableEmptyDisk2, 2, CachingTypes.None) // CreateOption: ATTACH
.WithNewDataDisk(creatableEmptyDisk3, 3, CachingTypes.None) // CreateOption: ATTACH
// End : Add bunch of empty managed disks
.WithDataDiskDefaultCachingType(CachingTypes.ReadOnly)
.WithDataDiskDefaultStorageAccountType(StorageAccountTypes.StandardLRS)
.WithSize(VirtualMachineSizeTypes.StandardD5V2)
.WithOSDiskCaching(CachingTypes.ReadWrite)
.Create();
virtualMachine1.Update()
.WithoutDataDisk(1)
.WithNewDataDisk(100, 6, CachingTypes.ReadWrite) // CreateOption: EMPTY
.Apply();
var dataDisks = virtualMachine1.DataDisks;
Assert.NotNull(dataDisks);
Assert.Equal(5, dataDisks.Count); // Removed one added another
Assert.True(dataDisks.ContainsKey(6));
Assert.False(dataDisks.ContainsKey(1));
}
finally
{
try
{
resourceManager.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
/**
* Create a virtual network with two Subnets – frontend and backend
* Frontend allows HTTP in and denies Internet out
* Backend denies Internet in and Internet out
* Create m Linux virtual machines in the frontend
* Create m Windows virtual machines in the backend.
*/
public static void RunSample(IAzure azure)
{
string rgName = SdkContext.RandomResourceName("rgNEPP", 24);
string frontEndNSGName = SdkContext.RandomResourceName("fensg", 24);
string backEndNSGName = SdkContext.RandomResourceName("bensg", 24);
string networkName = SdkContext.RandomResourceName("vnetCOMV", 24);
string storageAccountName = SdkContext.RandomResourceName("stgCOMV", 20);
try
{
// Create a resource group [Where all resources gets created]
IResourceGroup resourceGroup = azure.ResourceGroups
.Define(rgName)
.WithRegion(Region.USEast)
.Create();
//============================================================
// Define 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
var frontEndNSGCreatable = azure.NetworkSecurityGroups
.Define(frontEndNSGName)
.WithRegion(Region.USEast)
.WithExistingResourceGroup(resourceGroup)
.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();
//============================================================
// Define 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
var backEndNSGCreatable = azure.NetworkSecurityGroups
.Define(backEndNSGName)
.WithRegion(Region.USEast)
.WithExistingResourceGroup(resourceGroup)
.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();
Utilities.Log("Creating a security group for the front ends - allows SSH and HTTP");
Utilities.Log("Creating a security group for the back ends - allows SSH and denies all outbound internet traffic");
var networkSecurityGroups = azure.NetworkSecurityGroups
.Create(frontEndNSGCreatable, backEndNSGCreatable);
INetworkSecurityGroup frontendNSG = networkSecurityGroups.First(n => n.Name.Equals(frontEndNSGName, StringComparison.OrdinalIgnoreCase));
INetworkSecurityGroup backendNSG = networkSecurityGroups.First(n => n.Name.Equals(backEndNSGName, StringComparison.OrdinalIgnoreCase));
Utilities.Log("Created a security group for the front end: " + frontendNSG.Id);
Utilities.PrintNetworkSecurityGroup(frontendNSG);
Utilities.Log("Created a security group for the back end: " + backendNSG.Id);
Utilities.PrintNetworkSecurityGroup(backendNSG);
// Create Network [Where all the virtual machines get added to]
var network = azure.Networks
.Define(networkName)
.WithRegion(Region.USEast)
.WithExistingResourceGroup(resourceGroup)
.WithAddressSpace("172.16.0.0/16")
.DefineSubnet("Front-end")
.WithAddressPrefix("172.16.1.0/24")
.WithExistingNetworkSecurityGroup(frontendNSG)
.Attach()
.DefineSubnet("Back-end")
.WithAddressPrefix("172.16.2.0/24")
.WithExistingNetworkSecurityGroup(backendNSG)
.Attach()
.Create();
// Prepare Creatable Storage account definition [For storing VMs disk]
var creatableStorageAccount = azure.StorageAccounts
.Define(storageAccountName)
.WithRegion(Region.USEast)
.WithExistingResourceGroup(resourceGroup);
// Prepare a batch of Creatable Virtual Machines definitions
List <ICreatable <IVirtualMachine> > frontendCreatableVirtualMachines = new List <ICreatable <IVirtualMachine> >();
for (int i = 0; i < FrontendVMCount; i++)
{
var creatableVirtualMachine = azure.VirtualMachines
.Define("VM-FE-" + i)
.WithRegion(Region.USEast)
.WithExistingResourceGroup(resourceGroup)
.WithExistingPrimaryNetwork(network)
.WithSubnet("Front-end")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername(UserName)
.WithRootPassword(Password)
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.WithNewStorageAccount(creatableStorageAccount);
frontendCreatableVirtualMachines.Add(creatableVirtualMachine);
}
List <ICreatable <IVirtualMachine> > backendCreatableVirtualMachines = new List <ICreatable <IVirtualMachine> >();
for (int i = 0; i < BackendVMCount; i++)
{
var creatableVirtualMachine = azure.VirtualMachines
.Define("VM-BE-" + i)
.WithRegion(Region.USEast)
.WithExistingResourceGroup(resourceGroup)
.WithExistingPrimaryNetwork(network)
.WithSubnet("Back-end")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername(UserName)
.WithRootPassword(Password)
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.WithNewStorageAccount(creatableStorageAccount);
backendCreatableVirtualMachines.Add(creatableVirtualMachine);
}
var startTime = DateTimeOffset.Now.UtcDateTime;
Utilities.Log("Creating the virtual machines");
List <ICreatable <IVirtualMachine> > allCreatableVirtualMachines = new List <ICreatable <IVirtualMachine> >();
allCreatableVirtualMachines.AddRange(frontendCreatableVirtualMachines);
allCreatableVirtualMachines.AddRange(backendCreatableVirtualMachines);
var virtualMachines = azure.VirtualMachines.Create(allCreatableVirtualMachines.ToArray());
var endTime = DateTimeOffset.Now.UtcDateTime;
Utilities.Log("Created virtual machines");
foreach (var virtualMachine in virtualMachines)
{
Utilities.Log(virtualMachine.Id);
}
Utilities.Log($"Virtual machines create: took {(endTime - startTime).TotalSeconds } seconds");
}
finally
{
Utilities.Log($"Deleting resource group : {rgName}");
azure.ResourceGroups.DeleteByName(rgName);
Utilities.Log($"Deleted resource group : {rgName}");
}
}
public async Task Create()
{
try
{
var credentials = SdkContext.AzureCredentialsFactory.FromServicePrincipal(clientId, clientSecret, tenantId, AzureEnvironment.AzureGlobalCloud);
var azure = Azure
.Configure()
.WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic)
.Authenticate(credentials)
.WithSubscription(subscriptionId);
//var groupName = ResourceGroup;
var location = this.Region;
var resourceGroup = azure.ResourceGroups.Define(ResourceGroup) //groupname
.WithRegion(location)
.Create();
//Storage
string storageAccountName = SdkContext.RandomResourceName("st", 10);
//Console.WriteLine("Creating storage account...");
var storage = azure.StorageAccounts.Define(storageAccountName)
.WithRegion(this.Region)
.WithExistingResourceGroup(resourceGroup)
.Create();
var storageKeys = storage.GetKeys();
string storageConnectionString = "DefaultEndpointsProtocol=https;"
+ "AccountName=" + storage.Name
+ ";AccountKey=" + storageKeys[0].Value
+ ";EndpointSuffix=core.windows.net";
var account = CloudStorageAccount.Parse(storageConnectionString);
var serviceClient = account.CreateCloudBlobClient();
//Console.WriteLine("Creating container...");
var container = serviceClient.GetContainerReference("templates");
container.CreateIfNotExistsAsync().Wait();
var containerPermissions = new BlobContainerPermissions()
{
PublicAccess = BlobContainerPublicAccessType.Container
};
container.SetPermissionsAsync(containerPermissions).Wait();
//Console.WriteLine("Uploading template file...");
CloudBlockBlob templateblob = container.GetBlockBlobReference(templateJSON);
await templateblob.UploadFromFileAsync(templateJSON);
//Console.WriteLine("Uploading parameters file...");
CloudBlockBlob paramblob = container.GetBlockBlobReference(paramsJSON);
await paramblob.UploadFromFileAsync(paramsJSON);
//Deploy
var templatePath = String.Format("https://{0}.blob.core.windows.net/templates/{1}", storageAccountName, templateJSON);
var paramPath = String.Format("https://{0}.blob.core.windows.net/templates/{1}", storageAccountName, paramsJSON);
var deployment = azure.Deployments.Define("myDeployment")
.WithExistingResourceGroup(ResourceGroup)
.WithTemplateLink(templatePath, "1.0.0.0")
.WithParametersLink(paramPath, "1.0.0.0")
.WithMode(Microsoft.Azure.Management.ResourceManager.Fluent.Models.DeploymentMode.Incremental)
.Create();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public void CanWatchNetwork()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
string newName = SdkContext.RandomResourceName("nw", 6);
var groupName = SdkContext.RandomResourceName("rg", 6);
var resourcesGroupName = SdkContext.RandomResourceName("rg", 8);
// Create network watcher
var manager = TestHelper.CreateNetworkManager();
var computeManager = TestHelper.CreateComputeManager();
try
{
// make sure Network Watcher is disabled in current subscription and region as only one can exist
EnsureNetworkWatcherNotExists(manager.NetworkWatchers);
var nw = manager.NetworkWatchers.Define(newName)
.WithRegion(REGION)
.WithNewResourceGroup(groupName)
.Create();
// pre-create VMs to show topology on
ICreatedResources <IVirtualMachine> virtualMachines = EnsureNetwork(manager, computeManager, resourcesGroupName);
var vm0 = virtualMachines.ElementAt(0);
ITopology topology = nw.Topology()
.WithTargetResourceGroup(vm0.ResourceGroupName)
.Execute();
Assert.Equal(11, topology.Resources.Count);
Assert.True(topology.Resources.ContainsKey(vm0.PrimaryNetworkInterfaceId));
Assert.Equal(4, topology.Resources[vm0.PrimaryNetworkInterfaceId].Associations.Count);
ISecurityGroupView sgViewResult = nw.GetSecurityGroupView(virtualMachines.ElementAt(0).Id);
Assert.Equal(1, sgViewResult.NetworkInterfaces.Count);
Assert.Equal(virtualMachines.ElementAt(0).PrimaryNetworkInterfaceId,
sgViewResult.NetworkInterfaces.Keys.First());
IFlowLogSettings flowLogSettings =
nw.GetFlowLogSettings(vm0.GetPrimaryNetworkInterface().NetworkSecurityGroupId);
IStorageAccount storageAccount = EnsureStorageAccount(resourcesGroupName);
flowLogSettings.Update()
.WithLogging()
.WithStorageAccount(storageAccount.Id)
.WithRetentionPolicyDays(5)
.WithRetentionPolicyEnabled()
.Apply();
Assert.True(flowLogSettings.Enabled);
Assert.Equal(5, flowLogSettings.RetentionDays);
Assert.Equal(storageAccount.Id, flowLogSettings.StorageId);
INextHop nextHop = nw.NextHop().WithTargetResourceId(vm0.Id)
.WithSourceIPAddress("10.0.0.4")
.WithDestinationIPAddress("8.8.8.8")
.Execute();
Assert.Equal("System Route", nextHop.RouteTableId);
Assert.Equal(NextHopType.Internet, nextHop.NextHopType);
Assert.Null(nextHop.NextHopIpAddress);
IVerificationIPFlow verificationIPFlow = nw.VerifyIPFlow()
.WithTargetResourceId(vm0.Id)
.WithDirection(Direction.Outbound)
.WithProtocol(IpFlowProtocol.TCP)
.WithLocalIPAddress("10.0.0.4")
.WithRemoteIPAddress("8.8.8.8")
.WithLocalPort("443")
.WithRemotePort("443")
.Execute();
Assert.Equal(Access.Allow, verificationIPFlow.Access);
Assert.Equal("defaultSecurityRules/AllowInternetOutBound", verificationIPFlow.RuleName);
// test packet capture
IEnumerable <IPacketCapture> packetCaptures = nw.PacketCaptures.List();
Assert.Empty(packetCaptures);
IPacketCapture packetCapture = nw.PacketCaptures
.Define("NewPacketCapture")
.WithTarget(vm0.Id)
.WithStorageAccountId(storageAccount.Id)
.WithTimeLimitInSeconds(1500)
.DefinePacketCaptureFilter()
.WithProtocol(PcProtocol.TCP)
.WithLocalIPAddresses(new List <string>()
{
"127.0.0.1", "127.0.0.5"
})
.Attach()
.Create();
packetCaptures = nw.PacketCaptures.List();
Assert.Single(packetCaptures);
Assert.Equal("NewPacketCapture", packetCapture.Name);
Assert.Equal(1500, packetCapture.TimeLimitInSeconds);
Assert.Equal(PcProtocol.TCP, packetCapture.Filters[0].Protocol);
Assert.Equal("127.0.0.1;127.0.0.5", packetCapture.Filters[0].LocalIPAddress);
// Assert.assertEquals("Running", packetCapture.getStatus().packetCaptureStatus().toString());
packetCapture.Stop();
Assert.Equal("Stopped", packetCapture.GetStatus().PacketCaptureStatus.Value);
nw.PacketCaptures.DeleteByName(packetCapture.Name);
IConnectivityCheck connectivityCheck = nw.CheckConnectivity()
.ToDestinationResourceId(vm0.Id)
.ToDestinationPort(80)
.FromSourceVirtualMachine(virtualMachines.ElementAt(0).Id)
.Execute();
Assert.Equal("Reachable", connectivityCheck.ConnectionStatus.ToString());
computeManager.VirtualMachines.DeleteById(virtualMachines.ElementAt(1).Id);
topology.Execute();
Assert.Equal(10, topology.Resources.Count);
manager.ResourceManager.ResourceGroups.DeleteByName(nw.ResourceGroupName);
manager.ResourceManager.ResourceGroups.DeleteByName(resourcesGroupName);
}
finally
{
try
{
TestHelper.CreateResourceManager().ResourceGroups.DeleteByName(resourcesGroupName);
TestHelper.CreateResourceManager().ResourceGroups.DeleteByName(groupName);
}
catch { }
}
}
}
/**
* Azure Network sample for managing network watcher -
* - Create Network Watcher
* - Manage packet capture – track traffic to and from a virtual machine
* Create a VM
* Start a packet capture
* Stop a packet capture
* Get a packet capture
* Delete a packet capture
* - Verify IP flow – verify if traffic is allowed to or from a virtual machine
* Get the IP address of a NIC on a virtual machine
* Test IP flow on the NIC
* - Analyze next hop – get the next hop type and IP address for a virtual machine
* - Retrieve network topology for a resource group
* - Analyze Virtual Machine Security by examining effective network security rules applied to a VM
* Get security group view for the VM
* - Configure Network Security Group Flow Logs
* Get flow log settings
* Enable NSG flow log
* Disable NSG flow log
* - Delete network watcher
*/
public static void RunSample(IAzure azure)
{
string nwName = SdkContext.RandomResourceName("nw", 8);
string userName = Utilities.CreateUsername();
string vnetName = SdkContext.RandomResourceName("vnet", 20);
string subnetName = "subnet1";
string nsgName = SdkContext.RandomResourceName("nsg", 20);
string dnsLabel = SdkContext.RandomResourceName("pipdns", 20);
string rgName = SdkContext.RandomResourceName("rg", 24);
string saName = SdkContext.RandomResourceName("sa", 24);
string vmName = SdkContext.RandomResourceName("vm", 24);
string packetCaptureName = SdkContext.RandomResourceName("pc", 8);
INetworkWatcher nw = null;
try
{
//============================================================
// Create network watcher
Utilities.Log("Creating network watcher...");
nw = azure.NetworkWatchers.Define(nwName)
.WithRegion(region)
.WithNewResourceGroup()
.Create();
Utilities.Log("Created network watcher");
// Print the network watcher
Utilities.Print(nw);
//============================================================
// Manage packet capture – track traffic to and from a virtual machine
// Create network security group, virtual network and VM; add packetCapture extension to enable packet capture
Utilities.Log("Creating network security group...");
INetworkSecurityGroup nsg = azure.NetworkSecurityGroups.Define(nsgName)
.WithRegion(region)
.WithNewResourceGroup(rgName)
.DefineRule("DenyInternetInComing")
.DenyInbound()
.FromAddress("INTERNET")
.FromAnyPort()
.ToAnyAddress()
.ToPort(443)
.WithAnyProtocol()
.Attach()
.Create();
Utilities.Log("Creating virtual network...");
ICreatable <INetwork> virtualNetwork = azure.Networks.Define(vnetName)
.WithRegion(region)
.WithExistingResourceGroup(rgName)
.WithAddressSpace("192.168.0.0/16")
.DefineSubnet(subnetName)
.WithAddressPrefix("192.168.2.0/24")
.WithExistingNetworkSecurityGroup(nsg)
.Attach();
Utilities.Log("Creating virtual machine...");
IVirtualMachine vm = azure.VirtualMachines.Define(vmName)
.WithRegion(region)
.WithExistingResourceGroup(rgName)
.WithNewPrimaryNetwork(virtualNetwork)
.WithPrimaryPrivateIPAddressDynamic()
.WithNewPrimaryPublicIPAddress(dnsLabel)
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer14_04_Lts)
.WithRootUsername(userName)
.WithRootPassword("Abcdef.123456")
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.DefineNewExtension("packetCapture")
.WithPublisher("Microsoft.Azure.NetworkWatcher")
.WithType("NetworkWatcherAgentLinux")
.WithVersion("1.4")
.WithMinorVersionAutoUpgrade()
.Attach()
.Create();
// Create storage account
Utilities.Log("Creating storage account...");
IStorageAccount storageAccount = azure.StorageAccounts.Define(saName)
.WithRegion(region)
.WithExistingResourceGroup(rgName)
.Create();
// Start a packet capture
Utilities.Log("Creating packet capture...");
IPacketCapture packetCapture = nw.PacketCaptures
.Define(packetCaptureName)
.WithTarget(vm.Id)
.WithStorageAccountId(storageAccount.Id)
.WithTimeLimitInSeconds(1500)
.DefinePacketCaptureFilter()
.WithProtocol(PcProtocol.TCP)
.Attach()
.Create();
Utilities.Log("Created packet capture");
Utilities.Print(packetCapture);
// Stop a packet capture
Utilities.Log("Stopping packet capture...");
packetCapture.Stop();
Utilities.Print(packetCapture);
// Get a packet capture
Utilities.Log("Getting packet capture...");
IPacketCapture packetCapture1 = nw.PacketCaptures.GetByName(packetCaptureName);
Utilities.Print(packetCapture1);
// Delete a packet capture
Utilities.Log("Deleting packet capture");
nw.PacketCaptures.DeleteByName(packetCapture.Name);
//============================================================
// Verify IP flow – verify if traffic is allowed to or from a virtual machine
// Get the IP address of a NIC on a virtual machine
String ipAddress = vm.GetPrimaryNetworkInterface().PrimaryPrivateIP;
// Test IP flow on the NIC
Utilities.Log("Verifying IP flow for vm id " + vm.Id + "...");
IVerificationIPFlow verificationIPFlow = nw.VerifyIPFlow()
.WithTargetResourceId(vm.Id)
.WithDirection(Direction.Outbound)
.WithProtocol(IpFlowProtocol.TCP)
.WithLocalIPAddress(ipAddress)
.WithRemoteIPAddress("8.8.8.8")
.WithLocalPort("443")
.WithRemotePort("443")
.Execute();
Utilities.Print(verificationIPFlow);
//============================================================
// Analyze next hop – get the next hop type and IP address for a virtual machine
Utilities.Log("Calculating next hop...");
INextHop nextHop = nw.NextHop().WithTargetResourceId(vm.Id)
.WithSourceIPAddress(ipAddress)
.WithDestinationIPAddress("8.8.8.8")
.Execute();
Utilities.Print(nextHop);
//============================================================
// Retrieve network topology for a resource group
Utilities.Log("Getting topology...");
ITopology topology = nw.Topology()
.WithTargetResourceGroup(rgName)
.Execute();
Utilities.Print(topology);
//============================================================
// Analyze Virtual Machine Security by examining effective network security rules applied to a VM
// Get security group view for the VM
Utilities.Log("Getting security group view for a vm");
ISecurityGroupView sgViewResult = nw.GetSecurityGroupView(vm.Id);
Utilities.Print(sgViewResult);
//============================================================
// Configure Network Security Group Flow Logs
// Get flow log settings
IFlowLogSettings flowLogSettings = nw.GetFlowLogSettings(nsg.Id);
Utilities.Print(flowLogSettings);
// Enable NSG flow log
flowLogSettings.Update()
.WithLogging()
.WithStorageAccount(storageAccount.Id)
.WithRetentionPolicyDays(5)
.WithRetentionPolicyEnabled()
.Apply();
Utilities.Print(flowLogSettings);
// Disable NSG flow log
flowLogSettings.Update()
.WithoutLogging()
.Apply();
Utilities.Print(flowLogSettings);
//============================================================
// Delete network watcher
Utilities.Log("Deleting network watcher");
azure.NetworkWatchers.DeleteById(nw.Id);
Utilities.Log("Deleted network watcher");
}
finally
{
try
{
Utilities.Log("Deleting Resource Group: " + rgName);
azure.ResourceGroups.BeginDeleteByName(rgName);
if (nw != null)
{
Utilities.Log("Deleting network watcher resource group: " + nw.ResourceGroupName);
azure.ResourceGroups.BeginDeleteByName(nw.ResourceGroupName);
}
}
catch (NullReferenceException)
{
Utilities.Log("Did not create any resources in Azure. No clean up is necessary");
}
catch (Exception ex)
{
Utilities.Log(ex);
}
}
}
// Helper method to pre-create infrastructure to test Network Watcher
ICreatedResources <IVirtualMachine> EnsureNetwork(INetworkManager networkManager, IComputeManager computeManager, String groupName)
{
IVirtualMachines vms = computeManager.VirtualMachines;
// Create an NSG
INetworkSecurityGroup nsg = networkManager.NetworkSecurityGroups.Define(SdkContext.RandomResourceName("nsg", 8))
.WithRegion(REGION)
.WithNewResourceGroup(groupName)
.Create();
// Create a network for the VMs
INetwork network = networkManager.Networks.Define(SdkContext.RandomResourceName("net", 8))
.WithRegion(REGION)
.WithExistingResourceGroup(groupName)
.WithAddressSpace("10.0.0.0/28")
.DefineSubnet("subnet1")
.WithAddressPrefix("10.0.0.0/29")
.WithExistingNetworkSecurityGroup(nsg)
.Attach()
.WithSubnet("subnet2", "10.0.0.8/29")
.Create();
INetworkInterface nic = networkManager.NetworkInterfaces.Define(SdkContext.RandomResourceName("ni", 8))
.WithRegion(REGION)
.WithExistingResourceGroup(groupName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithNewPrimaryPublicIPAddress(SdkContext.RandomResourceName("pip", 8))
.WithIPForwarding()
.WithExistingNetworkSecurityGroup(nsg)
.Create();
// Create the requested number of VM definitions
String userName = "******";
var vmDefinitions = new List <ICreatable <IVirtualMachine> >();
var vm1 = vms.Define(SdkContext.RandomResourceName("vm", 15))
.WithRegion(REGION)
.WithExistingResourceGroup(groupName)
.WithExistingPrimaryNetworkInterface(nic)
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer14_04_Lts)
.WithRootUsername(userName)
.WithRootPassword("Abcdef.123456")
.WithSize(VirtualMachineSizeTypes.StandardA1)
.DefineNewExtension("packetCapture")
.WithPublisher("Microsoft.Azure.NetworkWatcher")
.WithType("NetworkWatcherAgentLinux")
.WithVersion("1.4")
.WithMinorVersionAutoUpgrade()
.Attach();
String vmName = SdkContext.RandomResourceName("vm", 15);
ICreatable <IVirtualMachine> vm2 = vms.Define(vmName)
.WithRegion(REGION)
.WithExistingResourceGroup(groupName)
.WithExistingPrimaryNetwork(network)
.WithSubnet(network.Subnets.Values.First().Name)
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer14_04_Lts)
.WithRootUsername(userName)
.WithRootPassword("Abcdef.123456")
.WithSize(VirtualMachineSizeTypes.StandardA1);
vmDefinitions.Add(vm1);
vmDefinitions.Add(vm2);
vms.Create(vmDefinitions);
var createdVMs2 = vms.Create(vmDefinitions);
return(createdVMs2);
}
public void CanTroubleshootConnection()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
string newName = SdkContext.RandomResourceName("nw", 6);
var groupName = SdkContext.RandomResourceName("rg", 6);
String gatewayName = SdkContext.RandomResourceName("vngw", 8);
String connectionName = SdkContext.RandomResourceName("vngwc", 8);
try
{
// Create network watcher
var manager = TestHelper.CreateNetworkManager();
// make sure Network Watcher is disabled in current subscription and region as only one can exist
EnsureNetworkWatcherNotExists(manager.NetworkWatchers);
var nw = manager.NetworkWatchers.Define(newName)
.WithRegion(REGION)
.WithNewResourceGroup(groupName)
.Create();
IVirtualNetworkGateway vngw1 = manager.VirtualNetworkGateways.Define(gatewayName)
.WithRegion(REGION)
.WithExistingResourceGroup(groupName)
.WithNewNetwork("10.11.0.0/16", "10.11.255.0/27")
.WithRouteBasedVpn()
.WithSku(VirtualNetworkGatewaySkuName.VpnGw1)
.Create();
IVirtualNetworkGateway vngw2 = manager.VirtualNetworkGateways.Define(gatewayName + "2")
.WithRegion(REGION)
.WithExistingResourceGroup(groupName)
.WithNewNetwork("10.41.0.0/16", "10.41.255.0/27")
.WithRouteBasedVpn()
.WithSku(VirtualNetworkGatewaySkuName.VpnGw1)
.Create();
IVirtualNetworkGatewayConnection connection1 = vngw1.Connections
.Define(connectionName)
.WithVNetToVNet()
.WithSecondVirtualNetworkGateway(vngw2)
.WithSharedKey("MySecretKey")
.Create();
// Create storage account to store troubleshooting information
IStorageAccount storageAccount = EnsureStorageAccount(groupName);
// Troubleshoot connection
ITroubleshooting troubleshooting = nw.Troubleshoot()
.WithTargetResourceId(connection1.Id)
.WithStorageAccount(storageAccount.Id)
.WithStoragePath(storageAccount.EndPoints.Primary.Blob + "results")
.Execute();
Assert.Equal("UnHealthy", troubleshooting.Code);
// Create corresponding connection on second gateway to make it work
vngw2.Connections
.Define(connectionName + "2")
.WithVNetToVNet()
.WithSecondVirtualNetworkGateway(vngw1)
.WithSharedKey("MySecretKey")
.Create();
TestHelper.Delay(250000);
troubleshooting = nw.Troubleshoot()
.WithTargetResourceId(connection1.Id)
.WithStorageAccount(storageAccount.Id)
.WithStoragePath(storageAccount.EndPoints.Primary.Blob + "results")
.Execute();
Assert.Equal("Healthy", troubleshooting.Code);
manager.ResourceManager.ResourceGroups.DeleteByName(nw.ResourceGroupName);
}
finally
{
try
{
TestHelper.CreateResourceManager().ResourceGroups.DeleteByName(groupName);
}
catch { }
}
}
}
/**
* Azure Key Vault sample for managing key vaults -
* - Create a key vault
* - Authorize an application
* - Update a key vault
* - alter configurations
* - change permissions
* - Create another key vault
* - List key vaults
* - Delete a key vault.
*/
public static void RunSample(IAzure azure)
{
string vaultName1 = SdkContext.RandomResourceName("vault1", 20);
string vaultName2 = SdkContext.RandomResourceName("vault2", 20);
string rgName = SdkContext.RandomResourceName("rgNEMV", 24);
try
{
//============================================================
// Create a key vault with empty access policy
Utilities.Log("Creating a key vault...");
var vault1 = azure.Vaults
.Define(vaultName1)
.WithRegion(Region.USWest)
.WithNewResourceGroup(rgName)
.WithEmptyAccessPolicy()
.Create();
Utilities.Log("Created key vault");
Utilities.PrintVault(vault1);
//============================================================
// Authorize an application
Utilities.Log("Authorizing the application associated with the current service principal...");
vault1 = vault1.Update()
.DefineAccessPolicy()
.ForServicePrincipal(SdkContext.AzureCredentialsFactory.FromFile(Environment.GetEnvironmentVariable("AZURE_AUTH_LOCATION")).ClientId)
.AllowKeyAllPermissions()
.AllowSecretPermissions(SecretPermissions.Get)
.AllowSecretPermissions(SecretPermissions.List)
.Attach()
.Apply();
Utilities.Log("Updated key vault");
Utilities.PrintVault(vault1);
//============================================================
// Update a key vault
Utilities.Log("Update a key vault to enable deployments and add permissions to the application...");
vault1 = vault1.Update()
.WithDeploymentEnabled()
.WithTemplateDeploymentEnabled()
.UpdateAccessPolicy(vault1.AccessPolicies[0].ObjectId)
.AllowSecretAllPermissions()
.Parent()
.Apply();
Utilities.Log("Updated key vault");
// Print the network security group
Utilities.PrintVault(vault1);
//============================================================
// Create another key vault
var vault2 = azure.Vaults
.Define(vaultName2)
.WithRegion(Region.USEast)
.WithExistingResourceGroup(rgName)
.DefineAccessPolicy()
.ForServicePrincipal(SdkContext.AzureCredentialsFactory.FromFile(Environment.GetEnvironmentVariable("AZURE_AUTH_LOCATION")).ClientId)
.AllowKeyPermissions(KeyPermissions.List)
.AllowKeyPermissions(KeyPermissions.Get)
.AllowKeyPermissions(KeyPermissions.Decrypt)
.AllowSecretPermissions(SecretPermissions.Get)
.Attach()
.Create();
Utilities.Log("Created key vault");
// Print the network security group
Utilities.PrintVault(vault2);
//============================================================
// List key vaults
Utilities.Log("Listing key vaults...");
foreach (var vault in azure.Vaults.ListByResourceGroup(rgName))
{
Utilities.PrintVault(vault);
}
//============================================================
// Delete key vaults
Utilities.Log("Deleting the key vaults");
azure.Vaults.DeleteById(vault1.Id);
azure.Vaults.DeleteById(vault2.Id);
Utilities.Log("Deleted the key vaults");
}
finally
{
try
{
Utilities.Log("Deleting Resource Group: " + rgName);
azure.ResourceGroups.DeleteByName(rgName);
Utilities.Log("Deleted Resource Group: " + rgName);
}
catch (NullReferenceException)
{
Utilities.Log("Did not create any resources in Azure. No clean up is necessary");
}
catch (Exception g)
{
Utilities.Log(g);
}
}
}
public void 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 { }
}
}
}
/**
* Azure Compute sample for managing virtual machines -
* - Create a virtual machine
* - Start a virtual machine
* - Stop a virtual machine
* - Restart a virtual machine
* - Update a virtual machine
* - Expand the OS drive
* - Tag a virtual machine (there are many possible variations here)
* - Attach data disks
* - Detach data disks
* - List virtual machines
* - Delete a virtual machine.
*/
public static void RunSample(IAzure azure)
{
string rgName = SdkContext.RandomResourceName("rgCOMV", 24);
string windowsVMName = SdkContext.RandomResourceName("wVM", 24);
string linuxVMName = SdkContext.RandomResourceName("lVM", 24);
try
{
var startTime = DateTimeOffset.Now.UtcDateTime;
var windowsVM = azure.VirtualMachines.Define(windowsVMName)
.WithRegion(Region.USEast)
.WithNewResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithPopularWindowsImage(KnownWindowsVirtualMachineImage.WindowsServer2012R2Datacenter)
.WithAdminUsername(UserName)
.WithAdminPassword(Password)
.WithUnmanagedDisks()
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.Create();
var endTime = DateTimeOffset.Now.UtcDateTime;
Utilities.Log($"Created VM: took {(endTime - startTime).TotalSeconds} seconds");
Utilities.PrintVirtualMachine(windowsVM);
windowsVM.Update()
.WithTag("who-rocks", "open source")
.WithTag("where", "on azure")
.Apply();
Utilities.Log("Tagged VM: " + windowsVM.Id);
//=============================================================
// Update - Attach data disks
windowsVM.Update()
.WithNewUnmanagedDataDisk(10)
.DefineUnmanagedDataDisk(DataDiskName)
.WithNewVhd(20)
.WithCaching(CachingTypes.ReadWrite)
.Attach()
.Apply();
Utilities.Log("Attached a new data disk" + DataDiskName + " to VM" + windowsVM.Id);
Utilities.PrintVirtualMachine(windowsVM);
windowsVM.Update()
.WithoutUnmanagedDataDisk(DataDiskName)
.Apply();
Utilities.Log("Detached data disk " + DataDiskName + " from VM " + windowsVM.Id);
//=============================================================
// Update - Resize (expand) the data disk
// First, deallocate the virtual machine and then proceed with resize
Utilities.Log("De-allocating VM: " + windowsVM.Id);
windowsVM.Deallocate();
Utilities.Log("De-allocated VM: " + windowsVM.Id);
var dataDisk = windowsVM.UnmanagedDataDisks[0];
windowsVM.Update()
.UpdateUnmanagedDataDisk(dataDisk.Name)
.WithSizeInGB(30)
.Parent()
.Apply();
//=============================================================
// Update - Expand the OS drive size by 10 GB
int osDiskSizeInGb = windowsVM.OSDiskSize;
if (osDiskSizeInGb == 0)
{
// Server is not returning the OS Disk size, possible bug in server
Utilities.Log("Server is not returning the OS disk size, possible bug in the server?");
Utilities.Log("Assuming that the OS disk size is 256 GB");
osDiskSizeInGb = 256;
}
windowsVM.Update()
.WithOSDiskSizeInGB(osDiskSizeInGb + 10)
.Apply();
Utilities.Log("Expanded VM " + windowsVM.Id + "'s OS disk to " + (osDiskSizeInGb + 10));
//=============================================================
// Start the virtual machine
Utilities.Log("Starting VM " + windowsVM.Id);
windowsVM.Start();
Utilities.Log("Started VM: " + windowsVM.Id + "; state = " + windowsVM.PowerState);
//=============================================================
// Restart the virtual machine
Utilities.Log("Restarting VM: " + windowsVM.Id);
windowsVM.Restart();
Utilities.Log("Restarted VM: " + windowsVM.Id + "; state = " + windowsVM.PowerState);
//=============================================================
// Stop (powerOff) the virtual machine
Utilities.Log("Powering OFF VM: " + windowsVM.Id);
windowsVM.PowerOff();
Utilities.Log("Powered OFF VM: " + windowsVM.Id + "; state = " + windowsVM.PowerState);
// Get the network where Windows VM is hosted
var network = windowsVM.GetPrimaryNetworkInterface().PrimaryIPConfiguration.GetNetwork();
//=============================================================
// Create a Linux VM in the same virtual network
Utilities.Log("Creating a Linux VM in the network");
var linuxVM = azure.VirtualMachines.Define(linuxVMName)
.WithRegion(Region.USEast)
.WithExistingResourceGroup(rgName)
.WithExistingPrimaryNetwork(network)
.WithSubnet("subnet1") // Referencing the default subnet name when no name specified at creation
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername(UserName)
.WithRootPassword(Password)
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.Create();
Utilities.Log("Created a Linux VM (in the same virtual network): " + linuxVM.Id);
Utilities.PrintVirtualMachine(linuxVM);
//=============================================================
// List virtual machines in the resource group
var resourceGroupName = windowsVM.ResourceGroupName;
Utilities.Log("Printing list of VMs =======");
foreach (var virtualMachine in azure.VirtualMachines.ListByResourceGroup(resourceGroupName))
{
Utilities.PrintVirtualMachine(virtualMachine);
}
//=============================================================
// Delete the virtual machine
Utilities.Log("Deleting VM: " + windowsVM.Id);
azure.VirtualMachines.DeleteById(windowsVM.Id);
Utilities.Log("Deleted VM: " + windowsVM.Id);
}
finally
{
try
{
Utilities.Log("Deleting Resource Group: " + rgName);
azure.ResourceGroups.DeleteByName(rgName);
Utilities.Log("Deleted Resource Group: " + rgName);
}
catch (Exception ex)
{
Utilities.Log(ex);
}
}
}
public void CanCreateImageFromManagedDisk()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var vmName = SdkContext.RandomResourceName("vm7-", 20);
var storageAccountName = SdkContext.RandomResourceName("stg", 17);
var uname = "juser";
var password = "******";
var resourceManager = TestHelper.CreateRollupClient();
var computeManager = TestHelper.CreateComputeManager();
var storageManager = TestHelper.CreateStorageManager();
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(storageAccountName)
.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)
.WithStorageAccountName(storageAccountName)
.Create();
// Create managed disk with Data from vm's lun0 data disk
//
var storageAccount = storageManager.StorageAccounts.GetByResourceGroup(rgName, storageAccountName);
var dataDiskName1 = SdkContext.RandomResourceName("dsk", 15);
var vmNativeDataDisk1 = dataDisks[0];
var managedDataDisk1 = computeManager.Disks.Define(dataDiskName1)
.WithRegion(Location)
.WithNewResourceGroup(rgName)
.WithData()
.FromVhd(vmNativeDataDisk1.VhdUri)
.WithStorageAccount(storageAccount)
.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)
.WithStorageAccountId(storageAccount.Id)
.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 { }
}
}
}
public void CanCRUDDiagnosticSettings()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var rgName = SdkContext.RandomResourceName("jMonitor_", 18);
var saName = SdkContext.RandomResourceName("jMonitorSa", 18);
var dsName = SdkContext.RandomResourceName("jMonitorDs_", 18);
var ehName = SdkContext.RandomResourceName("jMonitorEH", 18);
var azure = TestHelper.CreateRollupClient();
try
{
var vm = azure.VirtualMachines.List().First();
// clean all diagnostic settings.
var dsList = azure.DiagnosticSettings.ListByResource(vm.Id);
foreach (var dsd in dsList)
{
azure.DiagnosticSettings.DeleteById(dsd.Id);
}
var sa = azure.StorageAccounts
.Define(saName)
// Storage Account should be in the same region as resource
.WithRegion(vm.Region)
.WithNewResourceGroup(rgName)
.WithTag("tag1", "value1")
.Create();
var ehNamespace = azure.EventHubNamespaces
.Define(ehName)
// EventHub should be in the same region as resource
.WithRegion(vm.Region)
.WithExistingResourceGroup(rgName)
.WithNewManageRule("mngRule1")
.WithNewSendRule("sndRule1")
.Create();
var evenHubNsRule = ehNamespace.ListAuthorizationRules().First();
var categories = azure.DiagnosticSettings.ListCategoriesByResource(vm.Id);
Assert.NotNull(categories);
Assert.True(categories.Any());
var setting = azure.DiagnosticSettings
.Define(dsName)
.WithResource(vm.Id)
.WithStorageAccount(sa.Id)
.WithEventHub(evenHubNsRule.Id)
.WithLogsAndMetrics(categories, TimeSpan.FromMinutes(5), 7)
.Create();
Assert.Equal(vm.Id, setting.ResourceId, ignoreCase: true);
Assert.Equal(sa.Id, setting.StorageAccountId, ignoreCase: true);
Assert.Equal(evenHubNsRule.Id, setting.EventHubAuthorizationRuleId, ignoreCase: true);
Assert.Null(setting.EventHubName);
Assert.Null(setting.WorkspaceId);
Assert.False(setting.Logs.Any());
Assert.True(setting.Metrics.Any());
setting.Update()
.WithoutStorageAccount()
.WithoutLogs()
.Apply();
Assert.Equal(vm.Id, setting.ResourceId, ignoreCase: true);
Assert.Equal(evenHubNsRule.Id, setting.EventHubAuthorizationRuleId, ignoreCase: true);
Assert.Null(setting.StorageAccountId);
Assert.Null(setting.EventHubName);
Assert.Null(setting.WorkspaceId);
Assert.False(setting.Logs.Any());
Assert.True(setting.Metrics.Any());
var ds1 = azure.DiagnosticSettings.Get(setting.ResourceId, setting.Name);
CheckDiagnosticSettingValues(setting, ds1);
var ds2 = azure.DiagnosticSettings.GetById(setting.Id);
CheckDiagnosticSettingValues(setting, ds2);
dsList = azure.DiagnosticSettings.ListByResource(vm.Id);
Assert.NotNull(dsList);
Assert.Single(dsList);
var ds3 = dsList.First();
CheckDiagnosticSettingValues(setting, ds3);
azure.DiagnosticSettings.DeleteById(setting.Id);
dsList = azure.DiagnosticSettings.ListByResource(vm.Id);
Assert.NotNull(dsList);
Assert.False(dsList.Any());
}
finally
{
try
{
azure.ResourceGroups.BeginDeleteByName(rgName);
}
catch { }
}
}
}
public void CanCreateVirtualMachineFromCustomImageWithManagedDisks()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var publicIPDnsLabel = SdkContext.RandomResourceName("pip", 20);
var uname = "juser";
var password = "******";
// Create with implicit + explicit empty disks, check default and override
//
var vmName1 = "myvm1";
var explicitlyCreatedEmptyDiskName1 = SdkContext.RandomResourceName(vmName1 + "_mdisk_", 25);
var explicitlyCreatedEmptyDiskName2 = SdkContext.RandomResourceName(vmName1 + "_mdisk_", 25);
var explicitlyCreatedEmptyDiskName3 = SdkContext.RandomResourceName(vmName1 + "_mdisk_", 25);
var resourceManager = TestHelper.CreateRollupClient();
var computeManager = TestHelper.CreateComputeManager();
var rgName = TestUtilities.GenerateName("rgfluentchash-");
try
{
var resourceGroup = resourceManager.ResourceGroups
.Define(rgName)
.WithRegion(Location)
.Create();
var creatableEmptyDisk1 = computeManager.Disks
.Define(explicitlyCreatedEmptyDiskName1)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithData()
.WithSizeInGB(150);
var creatableEmptyDisk2 = computeManager.Disks
.Define(explicitlyCreatedEmptyDiskName2)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithData()
.WithSizeInGB(150);
var creatableEmptyDisk3 = computeManager.Disks
.Define(explicitlyCreatedEmptyDiskName3)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithData()
.WithSizeInGB(150);
var virtualMachine1 = computeManager.VirtualMachines
.Define(vmName1)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithNewPrimaryPublicIPAddress(publicIPDnsLabel)
.WithPopularLinuxImage(LinuxImage)
.WithRootUsername(uname)
.WithRootPassword(password)
// Start: Add bunch of empty managed disks
.WithNewDataDisk(100) // CreateOption: EMPTY
.WithNewDataDisk(100, 1, CachingTypes.ReadOnly) // CreateOption: EMPTY
.WithNewDataDisk(creatableEmptyDisk1) // CreateOption: ATTACH
.WithNewDataDisk(creatableEmptyDisk2, 2, CachingTypes.None) // CreateOption: ATTACH
.WithNewDataDisk(creatableEmptyDisk3, 3, CachingTypes.None) // CreateOption: ATTACH
// End : Add bunch of empty managed disks
.WithSize(VirtualMachineSizeTypes.StandardD5V2)
.WithOSDiskCaching(CachingTypes.ReadWrite)
.Create();
TestHelper.Delay(60 * 1000); // Wait for some time to ensure vm is publicly accessible
TestHelper.DeprovisionAgentInLinuxVM(virtualMachine1.GetPrimaryPublicIPAddress().Fqdn,
22,
uname,
password);
virtualMachine1.Deallocate();
virtualMachine1.Generalize();
var customImageName = SdkContext.RandomResourceName("img-", 10);
var customImage = computeManager.VirtualMachineCustomImages.Define(customImageName)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.FromVirtualMachine(virtualMachine1)
.Create();
Assert.NotNull(customImage);
Assert.NotNull(customImage.SourceVirtualMachineId);
Assert.Equal(customImage.SourceVirtualMachineId, virtualMachine1.Id, 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(5, customImage.DataDiskImages.Count);
foreach (ImageDataDisk imageDataDisk in customImage.DataDiskImages.Values)
{
Assert.Null(imageDataDisk.BlobUri);
Assert.NotNull(imageDataDisk.ManagedDisk.Id);
}
// Create virtual machine from the custom image
// This one relies on CRP's capability to create implicit data disks from the virtual machine
// image data disk images.
//
var vmName2 = "myvm2";
var virtualMachine2 = computeManager.VirtualMachines
.Define(vmName2)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithLinuxCustomImage(customImage.Id)
.WithRootUsername(uname)
.WithRootPassword(password)
// No explicit data disks, let CRP create it from the image's data disk images
.WithSize(VirtualMachineSizeTypes.StandardD5V2)
.WithOSDiskCaching(CachingTypes.ReadWrite)
.Create();
var dataDisks = virtualMachine2.DataDisks;
Assert.NotNull(dataDisks);
Assert.Equal(dataDisks.Count, customImage.DataDiskImages.Count);
foreach (var imageDataDisk in customImage.DataDiskImages.Values)
{
Assert.True(dataDisks.ContainsKey(imageDataDisk.Lun));
var dataDisk = dataDisks[imageDataDisk.Lun];
Assert.Equal(dataDisk.CachingType, imageDataDisk.Caching);
// Fails with new service.
//Assert.Equal(dataDisk.Size, (long)imageDataDisk.DiskSizeGB.Value);
}
// Create virtual machine from the custom image
// This one override the size and caching type of data disks from data disk images and
// adds one additional disk
//
var vmName3 = "myvm3";
var creatableVirtualMachine3 = computeManager.VirtualMachines
.Define(vmName3)
.WithRegion(Location)
.WithExistingResourceGroup(resourceGroup)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithLinuxCustomImage(customImage.Id)
.WithRootUsername(uname)
.WithRootPassword(password);
foreach (var dataDiskImage in customImage.DataDiskImages.Values)
{
// Explicitly override the properties of the data disks created from disk image
//
// CreateOption: FROM_IMAGE
var dataDisk = dataDisks[dataDiskImage.Lun];
creatableVirtualMachine3.WithNewDataDiskFromImage(dataDiskImage.Lun,
dataDisk.Size + 10, // increase size by 10 GB
CachingTypes.ReadOnly);
}
var virtualMachine3 = creatableVirtualMachine3
.WithNewDataDisk(200) // CreateOption: EMPTY
.WithSize(VirtualMachineSizeTypes.StandardD5V2)
.WithOSDiskCaching(CachingTypes.ReadWrite)
.Create();
dataDisks = virtualMachine3.DataDisks;
Assert.NotNull(dataDisks);
Assert.Equal(dataDisks.Count, customImage.DataDiskImages.Count + 1 /* count one extra empty disk */);
foreach (var imageDataDisk in customImage.DataDiskImages.Values)
{
Assert.True(dataDisks.ContainsKey(imageDataDisk.Lun));
var dataDisk = dataDisks[imageDataDisk.Lun];
Assert.Equal(CachingTypes.ReadOnly, dataDisk.CachingType);
// Fails with new service.
//Assert.Equal(dataDisk.Size, (long)imageDataDisk.DiskSizeGB + 10);
}
}
finally
{
try
{
resourceManager.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
public void CanCRUDActionGroups()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var rgName = SdkContext.RandomResourceName("jMonitor_", 18);
var saName = SdkContext.RandomResourceName("jMonitorSa", 18);
var dsName = SdkContext.RandomResourceName("jMonitorDs_", 18);
var ehName = SdkContext.RandomResourceName("jMonitorEH", 18);
var azure = TestHelper.CreateRollupClient();
try
{
var ag = azure.ActionGroups.Define("simpleActionGroup")
.WithNewResourceGroup(rgName, Region.AustraliaSouthEast)
.DefineReceiver("first")
.WithPushNotification("*****@*****.**")
.WithEmail("*****@*****.**")
.WithSms("1", "4255655665")
.WithVoice("1", "2062066050")
.WithWebhook("https://www.rate.am")
.Attach()
.DefineReceiver("second")
.WithEmail("*****@*****.**")
.WithWebhook("https://www.spyur.am")
.Attach()
.Create();
Assert.NotNull(ag);
Assert.Equal("simpleAction", ag.ShortName);
Assert.NotNull(ag.PushNotificationReceivers);
Assert.Equal(1, ag.PushNotificationReceivers.Count);
Assert.NotNull(ag.SmsReceivers);
Assert.Equal(1, ag.SmsReceivers.Count);
Assert.NotNull(ag.VoiceReceivers);
Assert.Equal(1, ag.VoiceReceivers.Count);
Assert.NotNull(ag.EmailReceivers);
Assert.Equal(2, ag.EmailReceivers.Count);
Assert.NotNull(ag.WebhookReceivers);
Assert.Equal(2, ag.WebhookReceivers.Count);
Assert.StartsWith("first", ag.EmailReceivers[0].Name);
Assert.StartsWith("second", ag.EmailReceivers[1].Name);
ag.Update()
.DefineReceiver("third")
.WithWebhook("https://www.news.am")
.Attach()
.UpdateReceiver("first")
.WithoutSms()
.Parent()
.WithoutReceiver("second")
.Apply();
Assert.Equal(2, ag.WebhookReceivers.Count);
Assert.Equal(1, ag.EmailReceivers.Count);
Assert.Equal(0, ag.SmsReceivers.Count);
var agGet = azure.ActionGroups.GetById(ag.Id);
Assert.Equal("simpleAction", agGet.ShortName);
Assert.Equal(2, agGet.WebhookReceivers.Count);
Assert.Equal(1, agGet.EmailReceivers.Count);
Assert.Equal(0, agGet.SmsReceivers.Count);
azure.ActionGroups.EnableReceiver(agGet.ResourceGroupName, agGet.Name, agGet.EmailReceivers.First().Name);
var agListByRg = azure.ActionGroups.ListByResourceGroup(rgName);
Assert.NotNull(agListByRg);
Assert.Single(agListByRg);
var agList = azure.ActionGroups.List();
Assert.NotNull(agListByRg);
Assert.True(agListByRg.Count() > 0);
azure.ActionGroups.DeleteById(ag.Id);
agListByRg = azure.ActionGroups.ListByResourceGroup(rgName);
Assert.Empty(agListByRg);
}
finally
{
try
{
azure.ResourceGroups.BeginDeleteByName(rgName);
}
catch { }
}
}
}
public void CanCreateVirtualMachineByAttachingManagedOsDisk()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var uname = "juser";
var password = "******";
var vmName = "myvm6";
var resourceManager = TestHelper.CreateRollupClient();
var computeManager = TestHelper.CreateComputeManager();
var rgName = TestUtilities.GenerateName("rgfluentchash-");
try
{
// Creates a native virtual machine
//
var nativeVM = computeManager.VirtualMachines
.Define(vmName)
.WithRegion(Location)
.WithNewResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithLatestLinuxImage("Canonical", "UbuntuServer", "14.04.2-LTS")
.WithRootUsername(uname)
.WithRootPassword(password)
.WithUnmanagedDisks() /* UN-MANAGED OS and DATA DISKS */
.WithSize(VirtualMachineSizeTypes.StandardD5V2)
.WithNewStorageAccount(SdkContext.RandomResourceName("stg", 17))
.WithOSDiskCaching(CachingTypes.ReadWrite)
.Create();
Assert.False(nativeVM.IsManagedDiskEnabled);
var osVhdUri = nativeVM.OSUnmanagedDiskVhdUri;
Assert.NotNull(osVhdUri);
computeManager.VirtualMachines.DeleteById(nativeVM.Id);
var diskName = SdkContext.RandomResourceName("dsk-", 15);
var osDisk = computeManager.Disks.Define(diskName)
.WithRegion(Location)
.WithExistingResourceGroup(rgName)
.WithLinuxFromVhd(osVhdUri)
.Create();
// Creates a managed virtual machine
//
var managedVM = computeManager.VirtualMachines
.Define(vmName)
.WithRegion(Location)
.WithExistingResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithSpecializedOSDisk(osDisk, OperatingSystemTypes.Linux)
.WithSize(VirtualMachineSizeTypes.StandardD5V2)
.WithOSDiskCaching(CachingTypes.ReadWrite)
.Create();
Assert.True(managedVM.IsManagedDiskEnabled);
Assert.Equal(managedVM.OSDiskId, osDisk.Id, ignoreCase: true);
}
finally
{
try
{
resourceManager.ResourceGroups.DeleteByName(rgName);
}
catch { }
}
}
}
public void CanCRUDMetricAlerts()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var rgName = SdkContext.RandomResourceName("jMonitor_", 18);
var saName = SdkContext.RandomResourceName("jMonitorSa", 18);
var dsName = SdkContext.RandomResourceName("jMonitorDs_", 18);
var ehName = SdkContext.RandomResourceName("jMonitorEH", 18);
var azure = TestHelper.CreateRollupClient();
try
{
var sa = azure.StorageAccounts.Define(saName)
.WithRegion(Region.USEast2)
.WithNewResourceGroup(rgName)
.Create();
var ag = azure.ActionGroups.Define("simpleActionGroup")
.WithExistingResourceGroup(rgName)
.DefineReceiver("first")
.WithPushNotification("*****@*****.**")
.WithEmail("*****@*****.**")
.WithSms("1", "4255655665")
.WithVoice("1", "2062066050")
.WithWebhook("https://www.rate.am")
.Attach()
.DefineReceiver("second")
.WithEmail("*****@*****.**")
.WithWebhook("https://www.spyur.am")
.Attach()
.Create();
var ma = azure.AlertRules.MetricAlerts.Define("somename")
.WithExistingResourceGroup(rgName)
.WithTargetResource(sa.Id)
.WithPeriod(TimeSpan.FromMinutes(15))
.WithFrequency(TimeSpan.FromMinutes(1))
.WithAlertDetails(3, "This alert rule is for U3 - Single resource multiple-criteria with dimensions-single timeseries")
.WithActionGroups(ag.Id)
.DefineAlertCriteria("Metric1")
.WithMetricName("Transactions", "Microsoft.Storage/storageAccounts")
.WithCondition(MetricAlertRuleCondition.GreaterThan, MetricAlertRuleTimeAggregation.Total, 100)
.WithDimension("ResponseType", "Success")
.WithDimension("ApiName", "GetBlob")
.Attach()
.Create();
Assert.NotNull(ma);
Assert.Equal(1, ma.Scopes.Count);
Assert.Equal(sa.Id, ma.Scopes.First());
Assert.Equal("This alert rule is for U3 - Single resource multiple-criteria with dimensions-single timeseries", ma.Description);
Assert.Equal(TimeSpan.FromMinutes(15), ma.WindowSize);
Assert.Equal(TimeSpan.FromMinutes(1), ma.EvaluationFrequency);
Assert.Equal(3, ma.Severity);
Assert.True(ma.Enabled);
Assert.True(ma.AutoMitigate);
Assert.Equal(1, ma.ActionGroupIds.Count);
Assert.Equal(ag.Id, ma.ActionGroupIds.First());
Assert.Equal(1, ma.AlertCriterias.Count);
var ac1 = ma.AlertCriterias.Values.First();
Assert.Equal("Metric1", ac1.Name);
Assert.Equal("Transactions", ac1.MetricName);
Assert.Equal("Microsoft.Storage/storageAccounts", ac1.MetricNamespace);
Assert.Equal(MetricAlertRuleCondition.GreaterThan, ac1.Condition);
Assert.Equal(MetricAlertRuleTimeAggregation.Total, ac1.TimeAggregation);
Assert.Equal(100.0, ac1.Threshold, 4);
Assert.Equal(2, ac1.Dimensions.Count);
MetricDimension d1 = ac1.Dimensions.ElementAt(0);
MetricDimension d2 = ac1.Dimensions.ElementAt(1);
Assert.Equal("ResponseType", d1.Name);
Assert.Equal(1, d1.Values.Count);
Assert.Equal("Success", d1.Values.ElementAt(0));
Assert.Equal("ApiName", d2.Name);
Assert.Equal(1, d2.Values.Count);
Assert.Equal("GetBlob", d2.Values.ElementAt(0));
var maFromGet = azure.AlertRules.MetricAlerts.GetById(ma.Id);
Assert.NotNull(maFromGet);
Assert.Equal(ma.Scopes.Count, maFromGet.Scopes.Count);
Assert.Equal(ma.Scopes.First(), maFromGet.Scopes.First());
Assert.Equal(ma.Description, maFromGet.Description);
Assert.Equal(ma.WindowSize, maFromGet.WindowSize);
Assert.Equal(ma.EvaluationFrequency, maFromGet.EvaluationFrequency);
Assert.Equal(ma.Severity, maFromGet.Severity);
Assert.Equal(ma.Enabled, maFromGet.Enabled);
Assert.Equal(ma.AutoMitigate, maFromGet.AutoMitigate);
Assert.Equal(ma.ActionGroupIds.Count, maFromGet.ActionGroupIds.Count);
Assert.Equal(ma.ActionGroupIds.First(), maFromGet.ActionGroupIds.First());
Assert.Equal(ma.AlertCriterias.Count, maFromGet.AlertCriterias.Count);
ac1 = maFromGet.AlertCriterias.Values.First();
Assert.Equal("Metric1", ac1.Name);
Assert.Equal("Transactions", ac1.MetricName);
Assert.Equal("Microsoft.Storage/storageAccounts", ac1.MetricNamespace);
Assert.Equal(MetricAlertRuleCondition.GreaterThan, ac1.Condition);
Assert.Equal(MetricAlertRuleTimeAggregation.Total, ac1.TimeAggregation);
Assert.Equal(100.00, ac1.Threshold, 4);
Assert.Equal(2, ac1.Dimensions.Count);
d1 = ac1.Dimensions.ElementAt(0);
d2 = ac1.Dimensions.ElementAt(1);
Assert.Equal("ResponseType", d1.Name);
Assert.Equal(1, d1.Values.Count);
Assert.Equal("Success", d1.Values.First());
Assert.Equal("ApiName", d2.Name);
Assert.Equal(1, d2.Values.Count);
Assert.Equal("GetBlob", d2.Values.First());
ma.Update()
.WithRuleDisabled()
.UpdateAlertCriteria("Metric1")
.WithCondition(MetricAlertRuleCondition.GreaterThan, MetricAlertRuleTimeAggregation.Total, 99)
.Parent()
.DefineAlertCriteria("Metric2")
.WithMetricName("SuccessE2ELatency", "Microsoft.Storage/storageAccounts")
.WithCondition(MetricAlertRuleCondition.GreaterThan, MetricAlertRuleTimeAggregation.Average, 200)
.WithDimension("ApiName", "GetBlob")
.Attach()
.Apply();
Assert.NotNull(ma);
Assert.Equal(1, ma.Scopes.Count);
Assert.Equal(sa.Id, ma.Scopes.First());
Assert.Equal("This alert rule is for U3 - Single resource multiple-criteria with dimensions-single timeseries", ma.Description);
Assert.Equal(TimeSpan.FromMinutes(15), ma.WindowSize);
Assert.Equal(TimeSpan.FromMinutes(1), ma.EvaluationFrequency);
Assert.Equal(3, ma.Severity);
Assert.False(ma.Enabled);
Assert.True(ma.AutoMitigate);
Assert.Equal(1, ma.ActionGroupIds.Count);
Assert.Equal(ag.Id, ma.ActionGroupIds.First());
Assert.Equal(2, ma.AlertCriterias.Count);
ac1 = ma.AlertCriterias.Values.ElementAt(0);
var ac2 = ma.AlertCriterias.Values.ElementAt(1);
Assert.Equal("Metric1", ac1.Name);
Assert.Equal("Transactions", ac1.MetricName);
Assert.Equal(MetricAlertRuleCondition.GreaterThan, ac1.Condition);
Assert.Equal(MetricAlertRuleTimeAggregation.Total, ac1.TimeAggregation);
Assert.Equal(99.0, ac1.Threshold, 4);
Assert.Equal(2, ac1.Dimensions.Count);
d1 = ac1.Dimensions.ElementAt(0);
d2 = ac1.Dimensions.ElementAt(1);
Assert.Equal("ResponseType", d1.Name);
Assert.Equal(1, d1.Values.Count);
Assert.Equal("Success", d1.Values.First());
Assert.Equal("ApiName", d2.Name);
Assert.Equal(1, d2.Values.Count);
Assert.Equal("GetBlob", d2.Values.First());
Assert.Equal("Metric2", ac2.Name);
Assert.Equal("SuccessE2ELatency", ac2.MetricName);
Assert.Equal("Microsoft.Storage/storageAccounts", ac2.MetricNamespace);
Assert.Equal(MetricAlertRuleCondition.GreaterThan, ac2.Condition);
Assert.Equal(MetricAlertRuleTimeAggregation.Average, ac2.TimeAggregation);
Assert.Equal(200.0, ac2.Threshold, 4);
Assert.Equal(1, ac2.Dimensions.Count);
d1 = ac2.Dimensions.First();
Assert.Equal("ApiName", d1.Name);
Assert.Equal(1, d1.Values.Count);
Assert.Equal("GetBlob", d1.Values.First());
maFromGet = azure.AlertRules.MetricAlerts.GetById(ma.Id);
Assert.NotNull(maFromGet);
Assert.Equal(1, maFromGet.Scopes.Count);
Assert.Equal(sa.Id, maFromGet.Scopes.First());
Assert.Equal("This alert rule is for U3 - Single resource multiple-criteria with dimensions-single timeseries", ma.Description);
Assert.Equal(TimeSpan.FromMinutes(15), maFromGet.WindowSize);
Assert.Equal(TimeSpan.FromMinutes(1), maFromGet.EvaluationFrequency);
Assert.Equal(3, maFromGet.Severity);
Assert.False(maFromGet.Enabled);
Assert.True(maFromGet.AutoMitigate);
Assert.Equal(1, maFromGet.ActionGroupIds.Count);
Assert.Equal(ag.Id, maFromGet.ActionGroupIds.First());
Assert.Equal(2, maFromGet.AlertCriterias.Count);
ac1 = maFromGet.AlertCriterias.Values.ElementAt(0);
ac2 = maFromGet.AlertCriterias.Values.ElementAt(1);
Assert.Equal("Metric1", ac1.Name);
Assert.Equal("Transactions", ac1.MetricName);
Assert.Equal(MetricAlertRuleCondition.GreaterThan, ac1.Condition);
Assert.Equal(MetricAlertRuleTimeAggregation.Total, ac1.TimeAggregation);
Assert.Equal(99.0, ac1.Threshold, 4);
Assert.Equal(2, ac1.Dimensions.Count);
d1 = ac1.Dimensions.ElementAt(0);
d2 = ac1.Dimensions.ElementAt(1);
Assert.Equal("ResponseType", d1.Name);
Assert.Equal(1, d1.Values.Count);
Assert.Equal("Success", d1.Values.First());
Assert.Equal("ApiName", d2.Name);
Assert.Equal(1, d2.Values.Count);
Assert.Equal("GetBlob", d2.Values.First());
Assert.Equal("Metric2", ac2.Name);
Assert.Equal("SuccessE2ELatency", ac2.MetricName);
Assert.Equal("Microsoft.Storage/storageAccounts", ac2.MetricNamespace);
Assert.Equal(MetricAlertRuleCondition.GreaterThan, ac2.Condition);
Assert.Equal(MetricAlertRuleTimeAggregation.Average, ac2.TimeAggregation);
Assert.Equal(200.0, ac2.Threshold, 4);
Assert.Equal(1, ac2.Dimensions.Count);
d1 = ac2.Dimensions.ElementAt(0);
Assert.Equal("ApiName", d1.Name);
Assert.Equal(1, d1.Values.Count);
Assert.Equal("GetBlob", d1.Values.First());
var alertsInRg = azure.AlertRules.MetricAlerts.ListByResourceGroup(rgName);
Assert.Single(alertsInRg);
maFromGet = alertsInRg.First();
Assert.NotNull(maFromGet);
Assert.Equal(1, maFromGet.Scopes.Count);
Assert.Equal(sa.Id, maFromGet.Scopes.First());
Assert.Equal("This alert rule is for U3 - Single resource multiple-criteria with dimensions-single timeseries", ma.Description);
Assert.Equal(TimeSpan.FromMinutes(15), maFromGet.WindowSize);
Assert.Equal(TimeSpan.FromMinutes(1), maFromGet.EvaluationFrequency);
Assert.Equal(3, maFromGet.Severity);
Assert.False(maFromGet.Enabled);
Assert.True(maFromGet.AutoMitigate);
Assert.Equal(1, maFromGet.ActionGroupIds.Count);
Assert.Equal(ag.Id, maFromGet.ActionGroupIds.First());
Assert.Equal(2, maFromGet.AlertCriterias.Count);
ac1 = maFromGet.AlertCriterias.Values.ElementAt(0);
ac2 = maFromGet.AlertCriterias.Values.ElementAt(1);
Assert.Equal("Metric1", ac1.Name);
Assert.Equal("Transactions", ac1.MetricName);
Assert.Equal(MetricAlertRuleCondition.GreaterThan, ac1.Condition);
Assert.Equal(MetricAlertRuleTimeAggregation.Total, ac1.TimeAggregation);
Assert.Equal(99.0, ac1.Threshold, 4);
Assert.Equal(2, ac1.Dimensions.Count);
d1 = ac1.Dimensions.ElementAt(0);
d2 = ac1.Dimensions.ElementAt(1);
Assert.Equal("ResponseType", d1.Name);
Assert.Equal(1, d1.Values.Count);
Assert.Equal("Success", d1.Values.First());
Assert.Equal("ApiName", d2.Name);
Assert.Equal(1, d2.Values.Count);
Assert.Equal("GetBlob", d2.Values.First());
Assert.Equal("Metric2", ac2.Name);
Assert.Equal("SuccessE2ELatency", ac2.MetricName);
Assert.Equal("Microsoft.Storage/storageAccounts", ac2.MetricNamespace);
Assert.Equal(MetricAlertRuleCondition.GreaterThan, ac2.Condition);
Assert.Equal(MetricAlertRuleTimeAggregation.Average, ac2.TimeAggregation);
Assert.Equal(200.0, ac2.Threshold, 4);
Assert.Equal(1, ac2.Dimensions.Count);
d1 = ac2.Dimensions.First();
Assert.Equal("ApiName", d1.Name);
Assert.Equal(1, d1.Values.Count);
Assert.Equal("GetBlob", d1.Values.First());
azure.AlertRules.MetricAlerts.DeleteById(ma.Id);
}
finally
{
try
{
azure.ResourceGroups.BeginDeleteByName(rgName);
}
catch { }
}
}
}
public async Task WebApp_Is_Found()
{
var resourceGroupName = SdkContext.RandomResourceName(nameof(AzureWebAppHealthCheckActionHandlerFixtures), 60);
var clientId = ExternalVariables.Get(ExternalVariable.AzureSubscriptionClientId);
var clientSecret = ExternalVariables.Get(ExternalVariable.AzureSubscriptionPassword);
var tenantId = ExternalVariables.Get(ExternalVariable.AzureSubscriptionTenantId);
var subscriptionId = ExternalVariables.Get(ExternalVariable.AzureSubscriptionId);
var credentials = SdkContext.AzureCredentialsFactory.FromServicePrincipal(clientId, clientSecret, tenantId,
AzureEnvironment.AzureGlobalCloud);
var azure = Microsoft.Azure.Management.Fluent.Azure
.Configure()
.WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic)
.Authenticate(credentials)
.WithSubscription(subscriptionId);
IResourceGroup resourceGroup = null;
try
{
resourceGroup = await azure.ResourceGroups
.Define(resourceGroupName)
.WithRegion(Region.USWest)
.CreateAsync();
var appServicePlan = await azure.AppServices.AppServicePlans
.Define(SdkContext.RandomResourceName(nameof(AzureWebAppHealthCheckActionHandlerFixtures), 60))
.WithRegion(resourceGroup.Region)
.WithExistingResourceGroup(resourceGroup)
.WithPricingTier(PricingTier.BasicB1)
.WithOperatingSystem(OperatingSystem.Windows)
.CreateAsync();
var webAppName = SdkContext.RandomResourceName(nameof(AzureWebAppHealthCheckActionHandlerFixtures), 60);
await azure.WebApps
.Define(webAppName)
.WithExistingWindowsPlan(appServicePlan)
.WithExistingResourceGroup(resourceGroup)
.WithRuntimeStack(WebAppRuntimeStack.NETCore)
.CreateAsync();
ActionHandlerTestBuilder.CreateAsync <AzureWebAppHealthCheckActionHandler, Program>()
.WithArrange(context =>
{
context.Variables.Add(AccountVariables.SubscriptionId,
subscriptionId);
context.Variables.Add(AccountVariables.TenantId,
tenantId);
context.Variables.Add(AccountVariables.ClientId,
clientId);
context.Variables.Add(AccountVariables.Password,
clientSecret);
context.Variables.Add(SpecialVariables.Action.Azure.ResourceGroupName, resourceGroupName);
context.Variables.Add(SpecialVariables.Action.Azure.WebAppName, webAppName);
context.Variables.Add(SpecialVariables.AccountType, AccountTypes.AzureServicePrincipalAccountType.ToString());
})
.WithAssert(result => result.WasSuccessful.Should().BeTrue())
.Execute();
}
finally
{
if (resourceGroup != null)
{
azure.ResourceGroups.DeleteByNameAsync(resourceGroupName).Ignore();
}
}
}
public void CanCRUDActivityLogAlerts()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
var rgName = SdkContext.RandomResourceName("jMonitor_", 18);
var saName = SdkContext.RandomResourceName("jMonitorSa", 18);
var dsName = SdkContext.RandomResourceName("jMonitorDs_", 18);
var ehName = SdkContext.RandomResourceName("jMonitorEH", 18);
var azure = TestHelper.CreateRollupClient();
try
{
var ag = azure.ActionGroups.Define("simpleActionGroup")
.WithNewResourceGroup(rgName, Region.USEast2)
.DefineReceiver("first")
.WithPushNotification("*****@*****.**")
.WithEmail("*****@*****.**")
.WithSms("1", "4255655665")
.WithVoice("1", "2062066050")
.WithWebhook("https://www.rate.am")
.Attach()
.DefineReceiver("second")
.WithEmail("*****@*****.**")
.WithWebhook("https://www.spyur.am")
.Attach()
.Create();
var justAvm = azure.VirtualMachines.List().First();
var ala = azure.AlertRules.ActivityLogAlerts.Define("somename")
.WithExistingResourceGroup(rgName)
.WithTargetSubscription(azure.SubscriptionId)
.WithDescription("AutoScale-VM-Creation-Failed")
.WithRuleEnabled()
.WithActionGroups(ag.Id)
.WithEqualsCondition("category", "Administrative")
.WithEqualsCondition("resourceId", justAvm.Id)
.WithEqualsCondition("operationName", "Microsoft.Compute/virtualMachines/delete")
.Create();
Assert.NotNull(ala);
Assert.Equal(1, ala.Scopes.Count);
Assert.Equal("/subscriptions/" + azure.SubscriptionId, ala.Scopes.First());
Assert.Equal("AutoScale-VM-Creation-Failed", ala.Description);
Assert.True(ala.Enabled);
Assert.Equal(1, ala.ActionGroupIds.Count);
Assert.Equal(ag.Id, ala.ActionGroupIds.First());
Assert.Equal(3, ala.EqualsConditions.Count);
Assert.Equal("Administrative", ala.EqualsConditions["category"]);
Assert.Equal(justAvm.Id, ala.EqualsConditions["resourceId"]);
Assert.Equal("Microsoft.Compute/virtualMachines/delete", ala.EqualsConditions["operationName"]);
var alaFromGet = azure.AlertRules.ActivityLogAlerts.GetById(ala.Id);
Assert.Equal(ala.Scopes.Count, alaFromGet.Scopes.Count);
Assert.Equal(ala.Scopes.First(), alaFromGet.Scopes.First());
Assert.Equal(ala.Description, alaFromGet.Description);
Assert.Equal(ala.Enabled, alaFromGet.Enabled);
Assert.Equal(ala.ActionGroupIds.Count, alaFromGet.ActionGroupIds.Count);
Assert.Equal(ala.ActionGroupIds.First(), alaFromGet.ActionGroupIds.First());
Assert.Equal(ala.EqualsConditions.Count, alaFromGet.EqualsConditions.Count);
Assert.Equal(ala.EqualsConditions["category"], alaFromGet.EqualsConditions["category"]);
Assert.Equal(ala.EqualsConditions["resourceId"], alaFromGet.EqualsConditions["resourceId"]);
Assert.Equal(ala.EqualsConditions["operationName"], alaFromGet.EqualsConditions["operationName"]);
ala.Update()
.WithRuleDisabled()
.WithoutEqualsCondition("operationName")
.WithEqualsCondition("status", "Failed")
.Apply();
Assert.Equal(1, ala.Scopes.Count);
Assert.Equal("/subscriptions/" + azure.SubscriptionId, ala.Scopes.First());
Assert.Equal("AutoScale-VM-Creation-Failed", ala.Description);
Assert.False(ala.Enabled);
Assert.Equal(1, ala.ActionGroupIds.Count);
Assert.Equal(ag.Id, ala.ActionGroupIds.First());
Assert.Equal(3, ala.EqualsConditions.Count);
Assert.Equal("Administrative", ala.EqualsConditions["category"]);
Assert.Equal(justAvm.Id, ala.EqualsConditions["resourceId"]);
Assert.Equal("Failed", ala.EqualsConditions["status"]);
Assert.False(ala.EqualsConditions.ContainsKey("operationName"));
var alertsInRg = azure.AlertRules.ActivityLogAlerts.ListByResourceGroup(rgName);
Assert.Single(alertsInRg);
alaFromGet = alertsInRg.First();
Assert.Equal(ala.Scopes.Count, alaFromGet.Scopes.Count);
Assert.Equal(ala.Scopes.First(), alaFromGet.Scopes.First());
Assert.Equal(ala.Description, alaFromGet.Description);
Assert.Equal(ala.Enabled, alaFromGet.Enabled);
Assert.Equal(ala.ActionGroupIds.Count, alaFromGet.ActionGroupIds.Count);
Assert.Equal(ala.ActionGroupIds.First(), alaFromGet.ActionGroupIds.First());
Assert.Equal(ala.EqualsConditions.Count, alaFromGet.EqualsConditions.Count);
Assert.Equal(ala.EqualsConditions["category"], alaFromGet.EqualsConditions["category"]);
Assert.Equal(ala.EqualsConditions["resourceId"], alaFromGet.EqualsConditions["resourceId"]);
Assert.Equal(ala.EqualsConditions["status"], alaFromGet.EqualsConditions["status"]);
Assert.Equal(ala.EqualsConditions.ContainsKey("operationName"), alaFromGet.EqualsConditions.ContainsKey("operationName"));
azure.AlertRules.ActivityLogAlerts.DeleteById(ala.Id);
}
finally
{
try
{
azure.ResourceGroups.BeginDeleteByName(rgName);
}
catch { }
}
}
}
/**
* Azure Network sample for managing internal load balancers -
*
* High-level ...
*
* - Create an internal load balancer that receives network traffic on
* port 1521 (Oracle SQL Node Port) and sends load-balanced traffic
* to two virtual machines
*
* - Create NAT rules for SSH and TELNET access to virtual
* machines behind the load balancer
*
* - Create a health probe
*
* Details ...
*
* Create an internal facing load balancer with ...
* - A frontend private IP address
* - One backend address pool which contains network interfaces for the virtual
* machines to receive 1521 (Oracle SQL Node Port) network traffic from the load balancer
* - One load balancing rule fto map port 1521 on the load balancer to
* ports in the backend address pool
* - One probe which contains HTTP health probe used to check availability
* of virtual machines in the backend address pool
* - Two inbound NAT rules which contain rules that map a public port on the load
* balancer to a port for a specific virtual machine in the backend address pool
* - this provides direct VM connectivity for SSH to port 22 and TELNET to port 23
*
* Create two network interfaces in the backend subnet ...
* - And associate network interfaces to backend pools and NAT rules
*
* Create two virtual machines in the backend subnet ...
* - And assign network interfaces
*
* Update an existing load balancer, configure TCP idle timeout
* Create another load balancer
* List load balancers
* Remove an existing load balancer.
*/
public static void RunSample(IAzure azure)
{
string rgName = SdkContext.RandomResourceName("rgNEML", 15);
string vnetName = SdkContext.RandomResourceName("vnet", 24);
string loadBalancerName3 = SdkContext.RandomResourceName("intlb3" + "-", 18);
string loadBalancerName4 = SdkContext.RandomResourceName("intlb4" + "-", 18);
string privateFrontEndName = loadBalancerName3 + "-BE";
string backendPoolName3 = loadBalancerName3 + "-BAP3";
string networkInterfaceName3 = SdkContext.RandomResourceName("nic3", 24);
string networkInterfaceName4 = SdkContext.RandomResourceName("nic4", 24);
string availSetName = SdkContext.RandomResourceName("av2", 24);
string vmName3 = SdkContext.RandomResourceName("lVM3", 24);
string vmName4 = SdkContext.RandomResourceName("lVM4", 24);
try
{
//=============================================================
// Create a virtual network with a frontend and a backend subnets
Utilities.Log("Creating virtual network with a frontend and a backend subnets...");
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.3.0/24")
.Attach()
.Create();
Utilities.Log("Created a virtual network");
// Print the virtual network details
Utilities.PrintVirtualNetwork(network);
//=============================================================
// Create an internal load balancer
// Create a frontend IP address
// Two backend address pools which contain network interfaces for the virtual
// machines to receive HTTP and HTTPS network traffic from the load balancer
// Two load balancing rules for HTTP and HTTPS to map public ports on the load
// balancer to ports in the backend address pool
// Two probes which contain HTTP and HTTPS health probes used to check availability
// of virtual machines in the backend address pool
// Two inbound NAT rules which contain rules that map a public port on the load
// balancer to a port for a specific virtual machine in the backend address pool
// - this provides direct VM connectivity for SSH to port 22 and TELNET to port 23
Utilities.Log("Creating an internal facing load balancer with ...");
Utilities.Log("- A private IP address");
Utilities.Log("- One backend address pool which contain network interfaces for the virtual\n"
+ " machines to receive 1521 network traffic from the load balancer");
Utilities.Log("- One load balancing rules for 1521 to map public ports on the load\n"
+ " balancer to ports in the backend address pool");
Utilities.Log("- One probe which contains HTTP health probe used to check availability\n"
+ " of virtual machines in the backend address pool");
Utilities.Log("- Two inbound NAT rules which contain rules that map a port on the load\n"
+ " balancer to a port for a specific virtual machine in the backend address pool\n"
+ " - this provides direct VM connectivity for SSH to port 22 and TELNET to port 23");
var loadBalancer3 = azure.LoadBalancers.Define(loadBalancerName3)
.WithRegion(Region.USEast)
.WithExistingResourceGroup(rgName)
// Add one rule that uses above backend and probe
.DefineLoadBalancingRule(TcpLoadBalancingRule)
.WithProtocol(TransportProtocol.Tcp)
.FromFrontend(privateFrontEndName)
.FromFrontendPort(OracleSQLNodePort)
.ToBackend(backendPoolName3)
.WithProbe(HttpProbe)
.Attach()
// Add two nat pools to enable direct VM connectivity for
// SSH to port 22 and TELNET to port 23
.DefineInboundNatRule(NatRule6000to22forVM3)
.WithProtocol(TransportProtocol.Tcp)
.FromFrontend(privateFrontEndName)
.FromFrontendPort(6000)
.ToBackendPort(22)
.Attach()
.DefineInboundNatRule(NatRule6001to23forVM3)
.WithProtocol(TransportProtocol.Tcp)
.FromFrontend(privateFrontEndName)
.FromFrontendPort(6001)
.ToBackendPort(23)
.Attach()
.DefineInboundNatRule(NatRule6002to22forVM4)
.WithProtocol(TransportProtocol.Tcp)
.FromFrontend(privateFrontEndName)
.FromFrontendPort(6002)
.ToBackendPort(22)
.Attach()
.DefineInboundNatRule(NatRule6003to23forVM4)
.WithProtocol(TransportProtocol.Tcp)
.FromFrontend(privateFrontEndName)
.FromFrontendPort(6003)
.ToBackendPort(23)
.Attach()
// Explicitly define the frontend
.DefinePrivateFrontend(privateFrontEndName)
.WithExistingSubnet(network, "Back-end")
.WithPrivateIPAddressStatic("172.16.3.5")
.Attach()
// Add one probes - one per rule
.DefineHttpProbe("httpProbe")
.WithRequestPath("/")
.Attach()
.Create();
// Print load balancer details
Utilities.Log("Created an internal load balancer");
Utilities.PrintLoadBalancer(loadBalancer3);
//=============================================================
// Create two network interfaces in the backend subnet
// associate network interfaces to NAT rules, backend pools
Utilities.Log("Creating two network interfaces in the backend subnet ...");
Utilities.Log("- And associating network interfaces to backend pools and NAT rules");
var networkInterfaceCreatables2 = new List <ICreatable <INetworkInterface> >();
ICreatable <INetworkInterface> networkInterface3Creatable;
ICreatable <INetworkInterface> networkInterface4Creatable;
networkInterface3Creatable = azure.NetworkInterfaces.Define(networkInterfaceName3)
.WithRegion(Region.USEast)
.WithNewResourceGroup(rgName)
.WithExistingPrimaryNetwork(network)
.WithSubnet("Back-end")
.WithPrimaryPrivateIPAddressDynamic()
.WithExistingLoadBalancerBackend(loadBalancer3, backendPoolName3)
.WithExistingLoadBalancerInboundNatRule(loadBalancer3, NatRule6000to22forVM3)
.WithExistingLoadBalancerInboundNatRule(loadBalancer3, NatRule6001to23forVM3);
networkInterfaceCreatables2.Add(networkInterface3Creatable);
networkInterface4Creatable = azure.NetworkInterfaces.Define(networkInterfaceName4)
.WithRegion(Region.USEast)
.WithNewResourceGroup(rgName)
.WithExistingPrimaryNetwork(network)
.WithSubnet("Back-end")
.WithPrimaryPrivateIPAddressDynamic()
.WithExistingLoadBalancerBackend(loadBalancer3, backendPoolName3)
.WithExistingLoadBalancerInboundNatRule(loadBalancer3, NatRule6002to22forVM4)
.WithExistingLoadBalancerInboundNatRule(loadBalancer3, NatRule6003to23forVM4);
networkInterfaceCreatables2.Add(networkInterface4Creatable);
var networkInterfaces2 = azure.NetworkInterfaces.Create(networkInterfaceCreatables2.ToArray());
// Print network interface details
Utilities.Log("Created two network interfaces");
Utilities.Log("Network Interface THREE -");
Utilities.PrintNetworkInterface(networkInterfaces2.ElementAt(0));
Utilities.Log();
Utilities.Log("Network Interface FOUR -");
Utilities.PrintNetworkInterface(networkInterfaces2.ElementAt(1));
//=============================================================
// Create an availability set
Utilities.Log("Creating an availability set ...");
var availSet2 = azure.AvailabilitySets.Define(availSetName)
.WithRegion(Region.USEast)
.WithNewResourceGroup(rgName)
.WithFaultDomainCount(2)
.WithUpdateDomainCount(4)
.Create();
Utilities.Log("Created first availability set: " + availSet2.Id);
Utilities.PrintAvailabilitySet(availSet2);
//=============================================================
// Create two virtual machines and assign network interfaces
Utilities.Log("Creating two virtual machines in the frontend subnet ...");
Utilities.Log("- And assigning network interfaces");
var virtualMachineCreatables2 = new List <ICreatable <IVirtualMachine> >();
ICreatable <IVirtualMachine> virtualMachine3Creatable;
ICreatable <IVirtualMachine> virtualMachine4Creatable;
virtualMachine3Creatable = azure.VirtualMachines.Define(vmName3)
.WithRegion(Region.USEast)
.WithExistingResourceGroup(rgName)
.WithExistingPrimaryNetworkInterface(networkInterfaces2.ElementAt(0))
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername(UserName)
.WithSsh(SshKey)
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.WithExistingAvailabilitySet(availSet2);
virtualMachineCreatables2.Add(virtualMachine3Creatable);
virtualMachine4Creatable = azure.VirtualMachines.Define(vmName4)
.WithRegion(Region.USEast)
.WithExistingResourceGroup(rgName)
.WithExistingPrimaryNetworkInterface(networkInterfaces2.ElementAt(1))
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername(UserName)
.WithSsh(SshKey)
.WithSize(VirtualMachineSizeTypes.Parse("Standard_D2a_v4"))
.WithExistingAvailabilitySet(availSet2);
virtualMachineCreatables2.Add(virtualMachine4Creatable);
var t1 = DateTime.UtcNow;
var virtualMachines = azure.VirtualMachines.Create(virtualMachineCreatables2.ToArray());
var t2 = DateTime.UtcNow;
Utilities.Log($"Created 2 Linux VMs: (took {(t2 - t1).TotalSeconds} seconds)");
Utilities.Log();
// Print virtual machine details
Utilities.Log("Virtual Machine THREE -");
Utilities.PrintVirtualMachine(virtualMachines.ElementAt(0));
Utilities.Log();
Utilities.Log("Virtual Machine FOUR - ");
Utilities.PrintVirtualMachine(virtualMachines.ElementAt(1));
//=============================================================
// Update a load balancer
// configure TCP idle timeout to 15 minutes
Utilities.Log("Updating the load balancer ...");
loadBalancer3.Update()
.UpdateLoadBalancingRule(TcpLoadBalancingRule)
.WithIdleTimeoutInMinutes(15)
.Parent()
.Apply();
Utilities.Log("Update the load balancer with a TCP idle timeout to 15 minutes");
//=============================================================
// Create another internal load balancer
// Create a frontend IP address
// Two backend address pools which contain network interfaces for the virtual
// machines to receive HTTP and HTTPS network traffic from the load balancer
// Two load balancing rules for HTTP and HTTPS to map public ports on the load
// balancer to ports in the backend address pool
// Two probes which contain HTTP and HTTPS health probes used to check availability
// of virtual machines in the backend address pool
// Two inbound NAT rules which contain rules that map a public port on the load
// balancer to a port for a specific virtual machine in the backend address pool
// - this provides direct VM connectivity for SSH to port 22 and TELNET to port 23
Utilities.Log("Creating another internal facing load balancer with ...");
Utilities.Log("- A private IP address");
Utilities.Log("- One backend address pool which contain network interfaces for the virtual\n"
+ " machines to receive 1521 network traffic from the load balancer");
Utilities.Log("- One load balancing rules for 1521 to map public ports on the load\n"
+ " balancer to ports in the backend address pool");
Utilities.Log("- One probe which contains HTTP health probe used to check availability\n"
+ " of virtual machines in the backend address pool");
Utilities.Log("- Two inbound NAT rules which contain rules that map a port on the load\n"
+ " balancer to a port for a specific virtual machine in the backend address pool\n"
+ " - this provides direct VM connectivity for SSH to port 22 and TELNET to port 23");
var loadBalancer4 = azure.LoadBalancers.Define(loadBalancerName4)
.WithRegion(Region.USEast)
.WithExistingResourceGroup(rgName)
// Add one rule that uses above backend and probe
.DefineLoadBalancingRule(TcpLoadBalancingRule)
.WithProtocol(TransportProtocol.Tcp)
.FromFrontend(privateFrontEndName)
.FromFrontendPort(OracleSQLNodePort)
.ToBackend(backendPoolName3)
.WithProbe(HttpProbe)
.Attach()
// Add two nat pools to enable direct VM connectivity for
// SSH to port 22 and TELNET to port 23
.DefineInboundNatRule(NatRule6000to22forVM3)
.WithProtocol(TransportProtocol.Tcp)
.FromFrontend(privateFrontEndName)
.FromFrontendPort(6000)
.ToBackendPort(22)
.Attach()
.DefineInboundNatRule(NatRule6001to23forVM3)
.WithProtocol(TransportProtocol.Tcp)
.FromFrontend(privateFrontEndName)
.FromFrontendPort(6001)
.ToBackendPort(23)
.Attach()
.DefineInboundNatRule(NatRule6002to22forVM4)
.WithProtocol(TransportProtocol.Tcp)
.FromFrontend(privateFrontEndName)
.FromFrontendPort(6002)
.ToBackendPort(22)
.Attach()
.DefineInboundNatRule(NatRule6003to23forVM4)
.WithProtocol(TransportProtocol.Tcp)
.FromFrontend(privateFrontEndName)
.FromFrontendPort(6003)
.ToBackendPort(23)
.Attach()
// Explicitly define the frontend
.DefinePrivateFrontend(privateFrontEndName)
.WithExistingSubnet(network, "Back-end")
.WithPrivateIPAddressStatic("172.16.3.15")
.Attach()
// Add one probes - one per rule
.DefineHttpProbe("httpProbe")
.WithRequestPath("/")
.Attach()
.Create();
// Print load balancer details
Utilities.Log("Created an internal load balancer");
Utilities.PrintLoadBalancer(loadBalancer4);
//=============================================================
// List load balancers
var loadBalancers = azure.LoadBalancers.List();
Utilities.Log("Walking through the list of load balancers");
foreach (var loadBalancer in loadBalancers)
{
Utilities.PrintLoadBalancer(loadBalancer);
}
//=============================================================
// Remove a load balancer
Utilities.Log("Deleting load balancer " + loadBalancerName4
+ "(" + loadBalancer4.Id + ")");
azure.LoadBalancers.DeleteById(loadBalancer4.Id);
Utilities.Log("Deleted load balancer" + loadBalancerName4);
}
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);
}
}
}
public static string CreateRandomName(string namePrefix)
{
return(SdkContext.RandomResourceName(namePrefix, 30));
}
/**
* Azure App Service basic sample for managing function apps.
* - Create 3 function apps under the same new app service plan:
* - 1, 2 are in the same resource group, 3 in a different one
* - 1, 3 are under the same consumption plan, 2 under a basic app service plan
* - List function apps
* - Delete a function app
*/
public static void RunSample(IAzure azure)
{
// New resources
string app1Name = SdkContext.RandomResourceName("webapp1-", 20);
string app2Name = SdkContext.RandomResourceName("webapp2-", 20);
string app3Name = SdkContext.RandomResourceName("webapp3-", 20);
string rg1Name = SdkContext.RandomResourceName("rg1NEMV_", 24);
string rg2Name = SdkContext.RandomResourceName("rg2NEMV_", 24);
try
{
//============================================================
// Create a function app with a new app service plan
Utilities.Log("Creating function app " + app1Name + " in resource group " + rg1Name + "...");
IFunctionApp app1 = azure.AppServices.FunctionApps
.Define(app1Name)
.WithRegion(Region.USWest)
.WithNewResourceGroup(rg1Name)
.Create();
Utilities.Log("Created function app " + app1.Name);
Utilities.Print(app1);
//============================================================
// Create a second function app with the same app service plan
Utilities.Log("Creating another function app " + app2Name + " in resource group " + rg1Name + "...");
IAppServicePlan plan = azure.AppServices.AppServicePlans.GetById(app1.AppServicePlanId);
IFunctionApp app2 = azure.AppServices.FunctionApps
.Define(app2Name)
.WithRegion(Region.USWest)
.WithExistingResourceGroup(rg1Name)
.WithNewAppServicePlan(PricingTier.BasicB1)
.Create();
Utilities.Log("Created function app " + app2.Name);
Utilities.Print(app2);
//============================================================
// Create a third function app with the same app service plan, but
// in a different resource group
Utilities.Log("Creating another function app " + app3Name + " in resource group " + rg2Name + "...");
IFunctionApp app3 = azure.AppServices.FunctionApps
.Define(app3Name)
.WithExistingAppServicePlan(plan)
.WithNewResourceGroup(rg2Name)
.Create();
Utilities.Log("Created function app " + app3.Name);
Utilities.Print(app3);
//============================================================
// stop and start app1, restart app 2
Utilities.Log("Stopping function app " + app1.Name);
app1.Stop();
Utilities.Log("Stopped function app " + app1.Name);
Utilities.Print(app1);
Utilities.Log("Starting function app " + app1.Name);
app1.Start();
Utilities.Log("Started function app " + app1.Name);
Utilities.Print(app1);
Utilities.Log("Restarting function app " + app2.Name);
app2.Restart();
Utilities.Log("Restarted function app " + app2.Name);
Utilities.Print(app2);
//=============================================================
// List function apps
Utilities.Log("Printing list of function apps in resource group " + rg1Name + "...");
foreach (IFunctionApp functionApp in azure.AppServices.FunctionApps.ListByResourceGroup(rg1Name))
{
Utilities.Print(functionApp);
}
Utilities.Log("Printing list of function apps in resource group " + rg2Name + "...");
foreach (IFunctionApp functionApp in azure.AppServices.FunctionApps.ListByResourceGroup(rg2Name))
{
Utilities.Print(functionApp);
}
//=============================================================
// Delete a function app
Utilities.Log("Deleting function app " + app1Name + "...");
azure.AppServices.FunctionApps.DeleteByResourceGroup(rg1Name, app1Name);
Utilities.Log("Deleted function app " + app1Name + "...");
Utilities.Log("Printing list of function apps in resource group " + rg1Name + " again...");
foreach (IFunctionApp functionApp in azure.AppServices.FunctionApps.ListByResourceGroup(rg1Name))
{
Utilities.Print(functionApp);
}
}
finally
{
try
{
Utilities.Log("Deleting Resource Group: " + rg2Name);
azure.ResourceGroups.DeleteByName(rg2Name);
Utilities.Log("Deleted Resource Group: " + rg2Name);
Utilities.Log("Deleting Resource Group: " + rg1Name);
azure.ResourceGroups.DeleteByName(rg1Name);
Utilities.Log("Deleted Resource Group: " + rg1Name);
}
catch (NullReferenceException)
{
Utilities.Log("Did not create any resources in Azure. No clean up is necessary");
}
catch (Exception g)
{
Utilities.Log(g);
}
}
}
/**
* Azure CDN sample for managing CDN profiles:
* - Create 8 web apps in 8 regions:
* * 2 in US
* * 2 in EU
* * 2 in Southeast
* * 1 in Brazil
* * 1 in Japan
* - Create CDN profile using Standard Verizon SKU with endpoints in each region of Web apps.
* - Load some content (referenced by Web Apps) to the CDN endpoints.
*/
public static void RunSample(IAzure azure)
{
string cdnProfileName = Utilities.CreateRandomName("cdnStandardProfile");
string rgName = SdkContext.RandomResourceName("rgCDN_", 24);
var appNames = new string[8];
try
{
azure.ResourceGroups.Define(rgName)
.WithRegion(Region.USCentral)
.Create();
// ============================================================
// Create 8 websites
for (int i = 0; i < 8; i++)
{
appNames[i] = SdkContext.RandomResourceName("webapp" + (i + 1) + "-", 20);
}
// 2 in US
CreateWebApp(azure, rgName, appNames[0], Region.USWest);
CreateWebApp(azure, rgName, appNames[1], Region.USEast);
// 2 in EU
CreateWebApp(azure, rgName, appNames[2], Region.EuropeWest);
CreateWebApp(azure, rgName, appNames[3], Region.EuropeNorth);
// 2 in Southeast
CreateWebApp(azure, rgName, appNames[4], Region.AsiaSouthEast);
CreateWebApp(azure, rgName, appNames[5], Region.AustraliaSouthEast);
// 1 in Brazil
CreateWebApp(azure, rgName, appNames[6], Region.BrazilSouth);
// 1 in Japan
CreateWebApp(azure, rgName, appNames[7], Region.JapanWest);
// =======================================================================================
// Create CDN profile using Standard Verizon SKU with endpoints in each region of Web apps.
Utilities.Log("Creating a CDN Profile");
// create Cdn Profile definition object that will let us do a for loop
// to define all 8 endpoints and then parallelize their creation
var profileDefinition = azure.CdnProfiles.Define(cdnProfileName)
.WithRegion(Region.USCentral)
.WithExistingResourceGroup(rgName)
.WithStandardVerizonSku();
// define all the endpoints. We need to keep track of the last creatable stage
// to be able to call create on the entire Cdn profile deployment definition.
ICreatable <ICdnProfile> cdnCreatable = null;
foreach (var webSite in appNames)
{
cdnCreatable = profileDefinition
.DefineNewEndpoint()
.WithOrigin(webSite + Suffix)
.WithHostHeader(webSite + Suffix)
.WithCompressionEnabled(true)
.WithContentTypeToCompress("application/javascript")
.WithQueryStringCachingBehavior(QueryStringCachingBehavior.IgnoreQueryString)
.Attach();
}
// create profile and then all the defined endpoints in parallel
ICdnProfile profile = cdnCreatable.Create();
// =======================================================================================
// Load some content (referenced by Web Apps) to the CDN endpoints.
var contentToLoad = new HashSet <string>();
contentToLoad.Add("/server.js");
contentToLoad.Add("/pictures/microsoft_logo.png");
foreach (ICdnEndpoint endpoint in profile.Endpoints.Values)
{
endpoint.LoadContent(contentToLoad);
}
}
finally
{
try
{
Utilities.Log("Deleting Resource Group: " + rgName);
azure.ResourceGroups.DeleteByName(rgName);
Utilities.Log("Deleted Resource Group: " + rgName);
}
catch
{
Utilities.Log("Did not create any resources in Azure. No clean up is necessary");
}
}
}
/**
* Azure CosmosDB sample -
* - Create a CosmosDB configured with eventual consistency
* - Get the credentials for the CosmosDB
* - add collection to the CosmosDB
* - Delete the CosmosDB.
*/
public static void RunSample(IAzure azure)
{
string cosmosDBName = SdkContext.RandomResourceName("docDb", 10);
string rgName = SdkContext.RandomResourceName("rgNEMV", 24);
try
{
//============================================================
// Create a CosmosDB.
Console.WriteLine("Creating a CosmosDB...");
ICosmosDBAccount cosmosDBAccount = azure.CosmosDBAccounts.Define(cosmosDBName)
.WithRegion(Region.USWest)
.WithNewResourceGroup(rgName)
.WithKind(DatabaseAccountKind.GlobalDocumentDB)
.WithEventualConsistency()
.WithWriteReplication(Region.USEast)
.WithReadReplication(Region.USCentral)
.Create();
Console.WriteLine("Created CosmosDB");
Utilities.Print(cosmosDBAccount);
//============================================================
// Get credentials for the CosmosDB.
Console.WriteLine("Get credentials for the CosmosDB");
DatabaseAccountListKeysResultInner databaseAccountListKeysResult = cosmosDBAccount.ListKeys();
string masterKey = databaseAccountListKeysResult.PrimaryMasterKey;
string endPoint = cosmosDBAccount.DocumentEndpoint;
//============================================================
// Connect to CosmosDB and add a collection
Console.WriteLine("Connecting and adding collection");
//CreateDBAndAddCollection(masterKey, endPoint);
//============================================================
// Delete CosmosDB
Console.WriteLine("Deleting the CosmosDB");
azure.CosmosDBAccounts.DeleteById(cosmosDBAccount.Id);
Console.WriteLine("Deleted the CosmosDB");
}
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 e)
{
Utilities.Log(e.StackTrace);
}
}
}
private async Task <IServicePrincipal> SubmitRolesAsync(IServicePrincipal sp, CancellationToken cancellationToken = default(CancellationToken))
{
// Delete
if (rolesToDelete.Count > 0)
{
foreach (string roleId in rolesToDelete)
{
await Manager().RoleAssignments.DeleteByIdAsync(roleId);
cachedRoleAssignments.Remove(roleId);
}
rolesToDelete.Clear();
}
// Create
if (rolesToCreate.Count > 0)
{
foreach (KeyValuePair <string, BuiltInRole> role in rolesToCreate)
{
IRoleAssignment roleAssignment = await manager.RoleAssignments.Define(SdkContext.RandomGuid())
.ForServicePrincipal(sp)
.WithBuiltInRole(role.Value)
.WithScope(role.Key)
.CreateAsync(cancellationToken);
cachedRoleAssignments.Add(roleAssignment.Id, roleAssignment);
}
rolesToCreate.Clear();
}
return(sp);
}
