public static async Task Run([TimerTrigger("0 0 9 * * *")] TimerInfo myTimer, ILogger log)
{
log.LogInformation("Running Resource Tagger...");
string ownerTagName = Environment.GetEnvironmentVariable("OwnerTag");
if (String.IsNullOrEmpty(ownerTagName))
{
log.LogCritical("Please set the OwnerTag environment variables");
return;
}
string subscriptionIds = Environment.GetEnvironmentVariable("SubscriptionIds");
if (String.IsNullOrEmpty(subscriptionIds))
{
log.LogCritical("Please set the SubscriptionIds environment variables");
return;
}
Azure.IAuthenticated azure;
AzureCredentials azureCreds;
if (Environment.GetEnvironmentVariable("UseManagedIdendity") == "true")
{
log.LogInformation("Using Managed Identity");
AzureCredentialsFactory factory = new AzureCredentialsFactory();
MSILoginInformation msi = new MSILoginInformation(MSIResourceType.AppService);
azureCreds = factory.FromMSI(msi, AzureEnvironment.AzureGlobalCloud);
}
else
{
log.LogInformation("Using Service Principal");
string clientId = Environment.GetEnvironmentVariable("ClientId");
string clientSecret = Environment.GetEnvironmentVariable("ClientSecret");
string tenantId = Environment.GetEnvironmentVariable("TenantId");
AzureCredentialsFactory factory = new AzureCredentialsFactory();
azureCreds = factory.FromServicePrincipal(clientId, clientSecret, tenantId,
AzureEnvironment.AzureGlobalCloud);
}
azure = Azure.Configure().Authenticate(azureCreds);
foreach (var subscriptionId in subscriptionIds.Split(",", StringSplitOptions.RemoveEmptyEntries))
{
log.LogInformation($"Looking for new resources without an owner tag in subscription {subscriptionId}");
var azureSub = azure.WithSubscription(subscriptionId);
var insightsClient = new Microsoft.Azure.Insights.InsightsClient(azureCreds);
insightsClient.SubscriptionId = subscriptionId;
var resourceGroups = azureSub.ResourceGroups.List();
foreach (var group in resourceGroups)
{
log.LogTrace($"Looking at resource group {group.Name}");
try
{
var defaultKeyValuePair = default(KeyValuePair <String, String>);
var ownerTag = defaultKeyValuePair;
if (group.Tags != null)
{
ownerTag = group.Tags.Where(tag => tag.Key.Equals(ownerTagName, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();
}
if (ownerTag.Equals(defaultKeyValuePair))
{
String startTime = DateTime.Now.ToUniversalTime().AddHours(-25).ToString("yyyy-MM-ddTHH:mm:ss.fffZ");
String endTime = DateTime.Now.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ss.fffZ");
String resourceId = group.Id;
string unknownOwner = "unknown";
string newOwner = unknownOwner;
var resourceGroupCreateLogs = await GetCreationLogs(startTime, endTime, resourceId, OPERATION_RESOURCEGROUP_WRITE, insightsClient);
if (resourceGroupCreateLogs.Length == 0)
{
log.LogInformation($"Resource group {group.Name}: did not find create operation - trying again");
startTime = DateTime.Now.ToUniversalTime().AddDays(-90).ToString("yyyy-MM-ddTHH:mm:ss.fffZ");
resourceGroupCreateLogs = await GetCreationLogs(startTime, endTime, resourceId, OPERATION_RESOURCEGROUP_WRITE, insightsClient);
}
if (resourceGroupCreateLogs.Length != 0)
{
newOwner = resourceGroupCreateLogs[0].Caller;
}
if (!unknownOwner.Equals(newOwner))
{
await group.Update().WithTag(ownerTagName, newOwner).ApplyAsync();
log.LogInformation($"Resource group {group.Name} tagged with owner {newOwner}");
}
else
{
log.LogInformation($"Resource group {group.Name}: did not find create operation, please tag manually");
}
}
else
{
log.LogTrace($"Resource group {group.Name} is already owned by {ownerTag.Value}");
}
}
catch (Exception ex)
{
log.LogError("Exception: " + ex);
}
}
}
}
public Singleton()
{
var credentials = SdkContext.AzureCredentialsFactory.FromServicePrincipal("clientId", "clientsecret", "tenantId", AzureEnvironment.AzureGlobalCloud);
azure = Azure.Configure().Authenticate(credentials).WithDefaultSubscription();
}
static async Task AsyncMain(string[] args)
{
var credentials = SdkContext.AzureCredentialsFactory.FromFile("../../Credentials/authfile.json");
var azure = Azure
.Configure()
.WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic)
.Authenticate(credentials)
.WithDefaultSubscription();
Console.WriteLine("Your subscription ID: \r\n" + azure.SubscriptionId);
Console.WriteLine("Creating an AKS Cluster!");
String rootUser = azureConfig.GetValue("RootUser").ToString();
String rgName = azureConfig.GetValue("ResourceGroup").ToString();
String aksName = azureConfig.GetValue("ClusterName").ToString();
String location = azureConfig.GetValue("Location").ToString();
String sshPublicKey = azureConfig.GetValue("SshPublicKey").ToString();
String clientSecret = JObject.Parse(File.ReadAllText("../../Credentials/authfile.json")).GetValue("clientSecret").ToString();
try {
Console.WriteLine("Trying to create the cluster...");
IKubernetesCluster cluster = await azure.KubernetesClusters.Define(aksName)
.WithRegion(location)
.WithNewResourceGroup(rgName)
.WithLatestVersion()
.WithRootUsername(rootUser)
.WithSshKey(sshPublicKey)
.WithServicePrincipalClientId(credentials.ClientId)
.WithServicePrincipalSecret(clientSecret)
.DefineAgentPool("agentpool")
.WithVirtualMachineSize(ContainerServiceVMSizeTypes.StandardA2)
.WithAgentPoolVirtualMachineCount(2)
.Attach()
.WithDnsPrefix("dns-" + aksName)
.CreateAsync();
Console.WriteLine("Created Kubernetes Cluster: " + cluster.Id);
Console.WriteLine(cluster);
Console.WriteLine("Updating Kubernetes Cluster. More VMs!!: " + cluster.Id);
await cluster.Update()
.WithAgentPoolVirtualMachineCount(4)
.ApplyAsync();
Console.WriteLine("Updated Kubernetes Cluster: " + cluster.Id);
Console.WriteLine(cluster);
} catch (Exception g)
{
Console.WriteLine(g);
}
finally {
try
{
Console.WriteLine("Deleting Resource Group: " + rgName);
await azure.ResourceGroups.BeginDeleteByNameAsync(rgName);
Console.WriteLine("Deleted Resource Group: " + rgName);
}
catch (NullReferenceException)
{
Console.WriteLine("Did not create any resources in Azure. No clean up is necessary");
}
catch (Exception g)
{
Console.WriteLine(g);
}
}
}
public static void Main(string[] args)
{
try
{
//=============================================================
// Authenticate
AzureCredentials credentials = AzureCredentials.FromFile(Environment.GetEnvironmentVariable("AZURE_AUTH_LOCATION"));
var azure = Azure
.Configure()
.WithLogLevel(HttpLoggingDelegatingHandler.Level.BASIC)
.Authenticate(credentials)
.WithDefaultSubscription();
// Print selected subscription
Console.WriteLine("Selected subscription: " + azure.SubscriptionId);
try
{
//=============================================================
// Create an availability set
Console.WriteLine("Creating an availability set");
var availSet1 = azure.AvailabilitySets.Define(availSetName1)
.WithRegion(Region.US_EAST)
.WithNewResourceGroup(rgName)
.WithFaultDomainCount(2)
.WithUpdateDomainCount(4)
.WithTag("cluster", "Windowslinux")
.WithTag("tag1", "tag1val")
.Create();
Console.WriteLine("Created first availability set: " + availSet1.Id);
Utilities.PrintAvailabilitySet(availSet1);
//=============================================================
// Define a virtual network for the VMs in this availability set
var network = azure.Networks
.Define(vnetName)
.WithRegion(Region.US_EAST)
.WithExistingResourceGroup(rgName)
.WithAddressSpace("10.0.0.0/28");
//=============================================================
// Create a Windows VM in the new availability set
Console.WriteLine("Creating a Windows VM in the availability set");
var vm1 = azure.VirtualMachines.Define(vm1Name)
.WithRegion(Region.US_EAST)
.WithExistingResourceGroup(rgName)
.WithNewPrimaryNetwork(network)
.WithPrimaryPrivateIpAddressDynamic()
.WithoutPrimaryPublicIpAddress()
.WithPopularWindowsImage(KnownWindowsVirtualMachineImage.WINDOWS_SERVER_2012_R2_DATACENTER)
.WithAdminUserName(userName)
.WithPassword(password)
.WithSize(VirtualMachineSizeTypes.StandardD3V2)
.WithExistingAvailabilitySet(availSet1)
.Create();
Console.WriteLine("Created first VM:" + vm1.Id);
Utilities.PrintVirtualMachine(vm1);
//=============================================================
// Create a Linux VM in the same availability set
Console.WriteLine("Creating a Linux VM in the availability set");
var vm2 = azure.VirtualMachines.Define(vm2Name)
.WithRegion(Region.US_EAST)
.WithExistingResourceGroup(rgName)
.WithNewPrimaryNetwork(network)
.WithPrimaryPrivateIpAddressDynamic()
.WithoutPrimaryPublicIpAddress()
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UBUNTU_SERVER_16_04_LTS)
.WithRootUserName(userName)
.WithPassword(password)
.WithSize(VirtualMachineSizeTypes.StandardD3V2)
.WithExistingAvailabilitySet(availSet1)
.Create();
Console.WriteLine("Created second VM: " + vm2.Id);
Utilities.PrintVirtualMachine(vm2);
//=============================================================
// Update - Tag the availability set
availSet1 = availSet1.Update()
.WithTag("server1", "nginx")
.WithTag("server2", "iis")
.WithoutTag("tag1")
.Apply();
Console.WriteLine("Tagged availability set: " + availSet1.Id);
//=============================================================
// Create another availability set
Console.WriteLine("Creating an availability set");
var availSet2 = azure.AvailabilitySets.Define(availSetName2)
.WithRegion(Region.US_EAST)
.WithExistingResourceGroup(rgName)
.Create();
Console.WriteLine("Created second availability set: " + availSet2.Id);
Utilities.PrintAvailabilitySet(availSet2);
//=============================================================
// List availability sets
var resourceGroupName = availSet1.ResourceGroupName;
Console.WriteLine("Printing list of availability sets =======");
foreach (var availabilitySet in azure.AvailabilitySets.ListByGroup(resourceGroupName))
{
Utilities.PrintAvailabilitySet(availabilitySet);
}
//=============================================================
// Delete an availability set
Console.WriteLine("Deleting an availability set: " + availSet2.Id);
azure.AvailabilitySets.Delete(availSet2.Id);
Console.WriteLine("Deleted availability set: " + availSet2.Id);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
finally
{
try
{
Console.WriteLine("Deleting Resource Group: " + rgName);
azure.ResourceGroups.Delete(rgName);
Console.WriteLine("Deleted Resource Group: " + rgName);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
static void Main(string[] args)
{
// Create the management client
var credentials = SdkContext.AzureCredentialsFactory
.FromFile(Environment.GetEnvironmentVariable("AZURE_AUTH_LOCATION"));
var azure = Azure
.Configure()
.WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic)
.Authenticate(credentials)
.WithDefaultSubscription();
// Create a resource group
var groupName = "myResourceGroup";
var location = Region.USCentral;
var resourceGroup = azure.ResourceGroups.Define(groupName)
.WithRegion(location)
.Create();
// Create a storage account
string storageAccountName = SdkContext.RandomResourceName("st", 10);
Console.WriteLine("Creating storage account...");
var storage = azure.StorageAccounts.Define(storageAccountName)
.WithRegion(location)
.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...");
var templateblob = container.GetBlockBlobReference("CreateVMTemplate.json");
templateblob.UploadFromFileAsync("..\\..\\CreateVMTemplate.json");
Console.WriteLine("Uploading parameters file...");
var paramblob = container.GetBlockBlobReference("Parameters.json");
paramblob.UploadFromFileAsync("..\\..\\Parameters.json");
// Deploy a template
Console.WriteLine("Deploying the uploaded VM template...");
var templatePath = "https://" + storageAccountName + ".blob.core.windows.net/templates/CreateVMTemplate.json";
var paramPath = "https://" + storageAccountName + ".blob.core.windows.net/templates/Parameters.json";
var deployment = azure.Deployments.Define("myDeployment")
.WithExistingResourceGroup(groupName)
.WithTemplateLink(templatePath, "1.0.0.0")
.WithParametersLink(paramPath, "1.0.0.0")
.WithMode(Microsoft.Azure.Management.ResourceManager.Fluent.Models.DeploymentMode.Incremental)
.Create();
Console.WriteLine("Deployed!");
Console.WriteLine("Press enter to delete the resource group...");
Console.ReadLine();
// Delete the resources
azure.ResourceGroups.DeleteByName(groupName);
}
public static void Main(string[] args)
{
try
{
//=================================================================
// Authenticate
var credentials = AzureCredentials.FromFile(Environment.GetEnvironmentVariable("AZURE_AUTH_LOCATION"));
var azure = Azure
.Configure()
.WithLogLevel(HttpLoggingDelegatingHandler.Level.BASIC)
.Authenticate(credentials)
.WithDefaultSubscription();
// Print selected subscription
Console.WriteLine("Selected subscription: " + azure.SubscriptionId);
try
{
//============================================================
// Assign a public IP address for a VM during its creation
// Define a public IP address to be used during VM creation time
Console.WriteLine("Creating a public IP address...");
var publicIpAddress = azure.PublicIpAddresses
.Define(publicIpAddressName1)
.WithRegion(Region.US_EAST)
.WithNewResourceGroup(rgName)
.WithLeafDomainLabel(publicIpAddressLeafDNS1)
.Create();
Console.WriteLine("Created a public IP address");
// Print public IP address details
Utilities.PrintIpAddress(publicIpAddress);
// Use the pre-created public IP for the new VM
Console.WriteLine("Creating a Windows VM");
var t1 = DateTime.UtcNow;
var vm = azure.VirtualMachines.Define(vmName)
.WithRegion(Region.US_EAST)
.WithExistingResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIpAddressDynamic()
.WithExistingPrimaryPublicIpAddress(publicIpAddress)
.WithPopularWindowsImage(KnownWindowsVirtualMachineImage.WINDOWS_SERVER_2012_R2_DATACENTER)
.WithAdminUserName(userName)
.WithPassword(password)
.WithSize(VirtualMachineSizeTypes.StandardD3V2)
.Create();
var t2 = DateTime.UtcNow;
Console.WriteLine("Created VM: (took "
+ (t2 - t1).TotalSeconds + " seconds) " + vm.Id);
// Print virtual machine details
Utilities.PrintVirtualMachine(vm);
//============================================================
// Gets the public IP address associated with the VM's primary NIC
Console.WriteLine("Public IP address associated with the VM's primary NIC [After create]");
// Print the public IP address details
Utilities.PrintIpAddress(vm.GetPrimaryPublicIpAddress());
//============================================================
// Assign a new public IP address for the VM
// Define a new public IP address
var publicIpAddress2 = azure.PublicIpAddresses
.Define(publicIpAddressName2)
.WithRegion(Region.US_EAST)
.WithNewResourceGroup(rgName)
.WithLeafDomainLabel(publicIpAddressLeafDNS2)
.Create();
// Update VM's primary NIC to use the new public IP address
Console.WriteLine("Updating the VM's primary NIC with new public IP address");
var primaryNetworkInterface = vm.GetPrimaryNetworkInterface();
primaryNetworkInterface
.Update()
.WithExistingPrimaryPublicIpAddress(publicIpAddress2)
.Apply();
//============================================================
// Gets the updated public IP address associated with the VM
// Get the associated public IP address for a virtual machine
Console.WriteLine("Public IP address associated with the VM's primary NIC [After Update]");
vm.Refresh();
Utilities.PrintIpAddress(vm.GetPrimaryPublicIpAddress());
//============================================================
// Remove public IP associated with the VM
Console.WriteLine("Removing public IP address associated with the VM");
vm.Refresh();
primaryNetworkInterface = vm.GetPrimaryNetworkInterface();
publicIpAddress = primaryNetworkInterface.PrimaryIpConfiguration.GetPublicIpAddress();
primaryNetworkInterface.Update()
.WithoutPrimaryPublicIpAddress()
.Apply();
Console.WriteLine("Removed public IP address associated with the VM");
//============================================================
// Delete the public ip
Console.WriteLine("Deleting the public IP address");
azure.PublicIpAddresses.Delete(publicIpAddress.Id);
Console.WriteLine("Deleted the public IP address");
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
finally
{
try
{
Console.WriteLine("Deleting Resource Group: " + rgName);
azure.ResourceGroups.Delete(rgName);
Console.WriteLine("Deleted Resource Group: " + rgName);
}
catch (NullReferenceException)
{
Console.WriteLine("Did not create any resources in Azure. No clean up is necessary");
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
//Create the management client. This will be used for all the operations
//that we will perform in Azure.
var credentials = SdkContext
.AzureCredentialsFactory
.FromFile("./azureauth.properties");
var azure = Azure.Configure()
.WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic)
.Authenticate(credentials)
.WithDefaultSubscription();
//First of all, we need to create a resource group where we will add all
//the resources
// needed for the virtual machine
var groupName = "mcaz204-ResourceGroup";
var vmName = "mcaz204VMTesting";
var location = Region.CanadaCentral;
var vNetName = "mcaz204VNET";
var vNetAddress = "172.16.0.0/16";
var subnetName = "mcaz204Subnet";
var subnetAddress = "172.16.0.0/24";
var nicName = "mcaz204NIC";
var adminUser = "******";
var adminPassword = "******";
var publicIPName = "mcaz204publicIP";
var nsgName = "mcaz204VNET-NSG";
Console.WriteLine($"Creating resource group {groupName} ...");
var resourceGroup = azure.ResourceGroups.Define(groupName)
.WithRegion(location)
.Create();
//Every virtual machine needs to be connected to a virtual network.
Console.WriteLine($"Creating virtual network {vNetName} ...");
var network = azure.Networks.Define(vNetName)
.WithRegion(location)
.WithExistingResourceGroup(groupName)
.WithAddressSpace(vNetAddress)
.WithSubnet(subnetName, subnetAddress)
.Create();
//You need a public IP to be able to connect to the VM from the Internet
Console.WriteLine($"Creating public IP {publicIPName} ...");
var publicIP = azure.PublicIPAddresses.Define(publicIPName)
.WithRegion(location)
.WithExistingResourceGroup(groupName)
.Create();
//You need a network security group for controlling the access to the VM
Console.WriteLine($"Creating Network Security Group {nsgName} ...");
var nsg = azure.NetworkSecurityGroups.Define(nsgName)
.WithRegion(location)
.WithExistingResourceGroup(groupName)
.Create();
//You need a security rule for allowing the access to the VM from the
//Internet
Console.WriteLine($"Creating a Security Rule for allowing the remote access");
nsg.Update().DefineRule("Allow-RDP")
.AllowInbound()
.FromAnyAddress()
.FromAnyPort()
.ToAnyAddress()
.ToPort(3389)
.WithProtocol(SecurityRuleProtocol.Tcp)
.WithPriority(100)
.WithDescription("Allow-RDP")
.Attach()
.Apply();
//Any virtual machine need a network interface for connecting to the
//virtual network
Console.WriteLine($"Creating network interface {nicName} ...");
var nic = azure.NetworkInterfaces.Define(nicName)
.WithRegion(location)
.WithExistingResourceGroup(groupName)
.WithExistingPrimaryNetwork(network)
.WithSubnet(subnetName)
.WithPrimaryPrivateIPAddressDynamic()
.WithExistingPrimaryPublicIPAddress(publicIP)
.WithExistingNetworkSecurityGroup(nsg)
.Create();
//Create the virtual machine
Console.WriteLine($"Creating virtual machine {vmName} ...");
azure.VirtualMachines.Define(vmName)
.WithRegion(location)
.WithExistingResourceGroup(groupName)
.WithExistingPrimaryNetworkInterface(nic)
.WithLatestWindowsImage("MicrosoftWindowsServer", "WindowsServer", "2012-R2-Datacenter")
.WithAdminUsername(adminUser)
.WithAdminPassword(adminPassword)
.WithComputerName(vmName)
.WithSize(VirtualMachineSizeTypes.StandardDS2V2)
.Create();
}
public static async Task CreateContainer(TaskLogger taskLogger, MyAppParameters myAppParameters)
{
// Get credentials
var credentials = SdkContext.AzureCredentialsFactory
.FromServicePrincipal(myAppParameters.AzureSubscriptionClientId,
myAppParameters.AzureSubscriptionClientSecret,
myAppParameters.TenantId,
AzureEnvironment.AzureGlobalCloud);
// Authenticate with Azure
var azure = Azure.Configure()
.Authenticate(credentials)
.WithDefaultSubscription();
var message = $"Authenticated with azure";
await taskLogger.Log(message).ConfigureAwait(false);
message = $"Getting resource group '{myAppParameters.ResourceGroupName}' details.";
await taskLogger.Log(message).ConfigureAwait(false);
// Check resource group exist or not.
IResourceGroup resourceGroup = azure.ResourceGroups.GetByName(myAppParameters.ResourceGroupName);
if (resourceGroup == null)
{
message = $"Resource group '{myAppParameters.ResourceGroupName}' not found.";
throw new Exception(message);
}
// Check container group exist or not.
IContainerGroup containerGroup = azure.ContainerGroups.GetByResourceGroup(myAppParameters.ResourceGroupName, myAppParameters.AgentName);
if (containerGroup != null)
{
message = $"Already container group with name '{myAppParameters.AgentName}' exist in resource group '{myAppParameters.ResourceGroupName}'.";
throw new Exception(message);
}
message = $"Creating container group '{myAppParameters.AgentName}' in resource group '{myAppParameters.ResourceGroupName}' with container image 'microsoft/vsts-agent:latest' ...";
await taskLogger.Log(message).ConfigureAwait(false);
message = $"This will take more than 15 mins... You can check container creating logs in Azure portal.";
await taskLogger.Log(message).ConfigureAwait(false);
var azureRegion = resourceGroup.Region;
var env = new Dictionary <string, string>
{
{ "VSTS_ACCOUNT", myAppParameters.PipelineAccountName },
{ "VSTS_TOKEN", myAppParameters.PATToken }, // This PAT token used to configure the agent. This PAT token should have permission to configure the agent else container moves to running state without configuring the agent
{ "VSTS_AGENT", myAppParameters.AgentName },
{ "VSTS_POOL", myAppParameters.AgentPoolName }
};
// Create container group with image.
await CreateContainerWithAsync(taskLogger, azure, resourceGroup.RegionName, myAppParameters, env);
// You can use below function to CreateContainerGroup With Polling
// await CreateContainerGroupWithPolling(taskLogger, azure, resourceGroup.RegionName, myAppParameters, env);
message = $"Azure pipeline agent container running..";
await taskLogger.Log(message).ConfigureAwait(false);
}
static void Main(string[] args)
{
var credentials = SdkContext.AzureCredentialsFactory
.FromServicePrincipal("clientId", "clientSecret", "tenantId", AzureEnvironment.AzureGlobalCloud);
var azure = Azure
.Configure()
.WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic)
.Authenticate(credentials)
.WithDefaultSubscription();
var groupName = "sampleResourceGroup";
var vmName = "VMWithCSharp";
var location = Region.EuropeWest;
var resourceGroup = azure.ResourceGroups.Define(groupName)
.WithRegion(location)
.Create();
var network = azure.Networks.Define("sampleVirtualNetwork")
.WithRegion(location)
.WithExistingResourceGroup(groupName)
.WithAddressSpace("10.0.0.0/16")
.WithSubnet("sampleSubNet", "10.0.0.0/24")
.Create();
var publicIPAddress = azure.PublicIPAddresses.Define("samplePublicIP")
.WithRegion(location)
.WithExistingResourceGroup(groupName)
.WithDynamicIP()
.Create();
var networkInterface = azure.NetworkInterfaces.Define("sampleNetWorkInterface")
.WithRegion(location)
.WithExistingResourceGroup(groupName)
.WithExistingPrimaryNetwork(network)
.WithSubnet("sampleSubNet")
.WithPrimaryPrivateIPAddressDynamic()
.WithExistingPrimaryPublicIPAddress(publicIPAddress)
.Create();
var availabilitySet = azure.AvailabilitySets.Define("sampleAvailabilitySet")
.WithRegion(location)
.WithExistingResourceGroup(groupName)
.WithSku(AvailabilitySetSkuTypes.Aligned)
.Create();
azure.VirtualMachines.Define(vmName)
.WithRegion(location)
.WithExistingResourceGroup(groupName)
.WithExistingPrimaryNetworkInterface(networkInterface)
.WithLatestWindowsImage("MicrosoftWindowsServer", "WindowsServer", "2012-R2-Datacenter")
.WithAdminUsername("sampleUser")
.WithAdminPassword("Sample123467")
.WithComputerName(vmName)
.WithExistingAvailabilitySet(availabilitySet)
.WithSize(VirtualMachineSizeTypes.StandardB1s)
.Create();
}
public static async Task Run(
[TimerTrigger("0 0 0 * * *")] TimerInfo myTimer,
TraceWriter log)
{
var tenantId = Config.TenantId;
var subscriptionId = Config.SubscriptionId;
var clientId = Config.ClientId;
var clientSecret = Config.ClientSecret;
var credentials =
SdkContext.AzureCredentialsFactory
.FromServicePrincipal(
clientId,
clientSecret,
tenantId,
AzureEnvironment.AzureGlobalCloud);
var logLevel = HttpLoggingDelegatingHandler.Level.Basic;
var azure = Azure.Configure()
.WithLogLevel(logLevel)
.Authenticate(credentials)
.WithSubscription(subscriptionId);
var resourceGroupName = Config.ResourceGroupName;
log.Info($"Firewall rules on database servers in {resourceGroupName} are updating...");
var res = await azure.WebApps
.Inner
.ListByResourceGroupWithHttpMessagesAsync(resourceGroupName)
.ConfigureAwait(false);
var webapps = res.Body.ToList();
var outboundIps = webapps.SelectMany(p => p.OutboundIpAddresses.Split(','))
.Distinct()
.ToList();
var tasks = new List <Task>();
var servers = await azure.SqlServers
.ListByResourceGroupAsync(resourceGroupName)
.ConfigureAwait(false);
foreach (var server in servers)
{
var registeredIps = server.FirewallRules
.List()
.ToDictionary(p => p.Name, p => p.StartIPAddress);
var ipsToExclude = registeredIps.Where(p => !outboundIps.Contains(p.Value))
.Select(p => p.Key)
.ToList();
var IpsToInclude = outboundIps.Where(p => !registeredIps.ContainsValue(p))
.ToList();
var tasksToExclude = ipsToExclude.Select(ip => server.FirewallRules
.DeleteAsync(ip));
var tasksToInclude = IpsToInclude.Select(ip => server.FirewallRules
.Define($"webapp-{ip.Replace(".", "-")}")
.WithIPAddressRange(ip, ip)
.CreateAsync());
tasks.AddRange(tasksToExclude);
tasks.AddRange(tasksToInclude);
}
await Task.WhenAll(tasks).ConfigureAwait(false);
log.Info($"Firewall rules on database servers in {resourceGroupName} have been updated.");
}
public static async Task Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req, TraceWriter log)
{
log.Info("C# HTTP trigger function processed a request.");
//Parse alert request
string requestBody = new StreamReader(req.Body).ReadToEnd();
Webhook data = new Webhook();
data = JsonConvert.DeserializeObject <Webhook>(requestBody);
Context alertResource = data.RequestBody.context;
IConfigurationRoot config = new ConfigurationBuilder()
.AddJsonFile("local.settings.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables()
.Build();
string tenantId = config.GetConnectionString("TenantId");
string clientId = config.GetConnectionString("clientId");
string clientKey = config.GetConnectionString("ClientKey");
if (string.IsNullOrEmpty(tenantId) || string.IsNullOrEmpty(clientId) || string.IsNullOrEmpty(clientKey))
{
log.Error("Serivice credentials are null. Check connection string settings");
return;
}
AzureCredentials credentials = SdkContext.AzureCredentialsFactory.FromServicePrincipal(clientId, clientKey, tenantId, AzureEnvironment.AzureGlobalCloud);
IAzure azure = Azure.Configure().Authenticate(credentials).WithSubscription(alertResource.subscriptionId);
if (azure == null)
{
log.Error("Error: Issues logging into Azure subscription: " + alertResource.subscriptionId + ". Exiting.");
return;
}
IVirtualMachine VM = await azure.VirtualMachines.GetByIdAsync(alertResource.resourceId);
if (VM == null)
{
log.Error("Error: VM: " + alertResource.resourceId + "was not found. Exiting.");
return;
}
INetworkWatcher networkWatcher = await EnsureNetworkWatcherExists(azure, VM.Region, log);
InstallNetworkWatcherExtension(VM, log);
string storageAccountId = Environment.GetEnvironmentVariable("PacketCaptureStorageAccount");
var storageAccount = await azure.StorageAccounts.GetByIdAsync(storageAccountId);
if (storageAccount == null)
{
log.Error("Storage Account: " + storageAccountId + " not found. Exiting.");
return;
}
string packetCaptureName = VM.Name.Substring(0, System.Math.Min(63, VM.Name.Length)) + System.DateTime.Now.ToString("s").Replace(":", "");
IPacketCaptures packetCapturesObj = networkWatcher.PacketCaptures;
var packetCaptures = packetCapturesObj.List().ToList();
if (packetCaptures.Count >= 10)
{
log.Info("More than 10 Captures, finding oldest.");
var packetCaptureTasks = new List <Task <IPacketCaptureStatus> >();
foreach (IPacketCapture pcap in packetCaptures)
{
packetCaptureTasks.Add(pcap.GetStatusAsync());
}
var packetCaptureStatuses = new List <Tuple <IPacketCapture, IPacketCaptureStatus> >();
for (int i = 0; i < packetCaptureTasks.Count; ++i)
{
packetCaptureStatuses.Add(new Tuple <IPacketCapture, IPacketCaptureStatus>(packetCaptures[i], await packetCaptureTasks[i]));
}
packetCaptureStatuses.Sort((Tuple <IPacketCapture, IPacketCaptureStatus> first, Tuple <IPacketCapture, IPacketCaptureStatus> second) =>
{
return(first.Item2.CaptureStartTime.CompareTo(second.Item2.CaptureStartTime));
});
log.Info("Removing: " + packetCaptureStatuses.First().Item1.Name);
await networkWatcher.PacketCaptures.DeleteByNameAsync(packetCaptureStatuses.First().Item1.Name);
}
log.Info("Creating Packet Capture");
await networkWatcher.PacketCaptures
.Define(packetCaptureName)
.WithTarget(VM.Id)
.WithStorageAccountId(storageAccount.Id)
.WithTimeLimitInSeconds(15)
.CreateAsync();
log.Info("Packet Capture created successfully");
}
static void Main(string[] args)
{
var settingsFile = "C:\\Users\\Beheerder\\source\\repos\\az203\\provision.vm\\azureauth.properties";
WriteLine($"Creating Credentials from {settingsFile}...");
var credentials =
SdkContext.AzureCredentialsFactory.FromFile(settingsFile);
WriteLine(credentials.ToString());
var azure = Azure.Configure().WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic)
.Authenticate(credentials)
.WithDefaultSubscription();
var groupName = "az203.iaas.code";
var vmName = "az203ws12r2code";
var location = Region.EuropeWest;
WriteLine("Creating Resource Group..");
var resourceGroup = azure.ResourceGroups
.Define(groupName)
.WithRegion(location)
.Create();
WriteLine("Creating Availablity Set..");
var availabilitySet = azure.AvailabilitySets
.Define("az203.as")
.WithRegion(location)
.WithExistingResourceGroup(resourceGroup)
.WithSku(AvailabilitySetSkuTypes.Aligned).Create();
WriteLine("Creating Public IP..");
var publicIpAddress = azure.PublicIPAddresses
.Define($"{vmName}.pip.1")
.WithRegion(location)
.WithExistingResourceGroup(groupName)
.WithDynamicIP().Create();
WriteLine("Creating VNet..");
var vnet = azure.Networks.Define("az203.vnet")
.WithRegion(location)
.WithExistingResourceGroup(groupName)
.WithAddressSpace("10.0.0.0/16")
.WithSubnet("az203.sn.1", "10.0.0.0/24")
.Create();
WriteLine("Creating NIC..");
var nic = azure.NetworkInterfaces.Define($"{vmName}.nic.1")
.WithRegion(location)
.WithExistingResourceGroup(groupName)
.WithExistingPrimaryNetwork(vnet)
.WithSubnet("az203.sn.1")
.WithPrimaryPrivateIPAddressDynamic()
.WithExistingPrimaryPublicIPAddress(publicIpAddress)
.Create();
WriteLine("Creating Virtual Machine..");
azure.VirtualMachines.Define(vmName)
.WithRegion(location)
.WithExistingResourceGroup(groupName)
.WithExistingPrimaryNetworkInterface(nic)
.WithLatestWindowsImage("MicrosoftWindowsServer", "WindowsServer", "2012-R2-Datacenter")
.WithAdminUsername("demoadmin")
.WithAdminPassword("Azure12345678!@#")
.WithComputerName(vmName)
.WithExistingAvailabilitySet(availabilitySet)
.WithSize(VirtualMachineSizeTypes.StandardB1s)
.Create();
// if you want a managed disk..
// var managedDisk = azure.Disks.Define("myosdisk")
// .WithRegion(location)
// .WithExistingResourceGroup(groupName)
// .WithWindowsFromVhd("https://mystorage.blob.core.windows.net/vhds/myosdisk.vhd")
// .WithSizeInGB(128)
// .WithSku(DiskSkuTypes.PremiumLRS)
// .Create();
//
// azure.VirtualMachines.Define(vmName)
// .WithRegion(location)
// .WithExistingResourceGroup(groupName)
// .WithExistingPrimaryNetworkInterface(nic)
// .WithSpecializedOSDisk(managedDisk, OperatingSystemTypes.Windows)
// .WithExistingAvailabilitySet(availabilitySet)
// .WithSize(VirtualMachineSizeTypes.StandardDS1)
// .Create();
var vm = azure.VirtualMachines.GetByResourceGroup(groupName, vmName);
WriteLine("Getting information about the virtual machine...");
WriteLine("hardwareProfile");
WriteLine(" vmSize: " + vm.Size);
WriteLine("storageProfile");
WriteLine(" imageReference");
WriteLine(" publisher: " + vm.StorageProfile.ImageReference.Publisher);
WriteLine(" offer: " + vm.StorageProfile.ImageReference.Offer);
WriteLine(" sku: " + vm.StorageProfile.ImageReference.Sku);
WriteLine(" version: " + vm.StorageProfile.ImageReference.Version);
WriteLine(" osDisk");
WriteLine(" osType: " + vm.StorageProfile.OsDisk.OsType);
WriteLine(" name: " + vm.StorageProfile.OsDisk.Name);
WriteLine(" createOption: " + vm.StorageProfile.OsDisk.CreateOption);
WriteLine(" caching: " + vm.StorageProfile.OsDisk.Caching);
WriteLine("osProfile");
WriteLine(" computerName: " + vm.OSProfile.ComputerName);
WriteLine(" adminUsername: "******" provisionVMAgent: " + vm.OSProfile.WindowsConfiguration.ProvisionVMAgent.Value);
WriteLine(" enableAutomaticUpdates: " + vm.OSProfile.WindowsConfiguration.EnableAutomaticUpdates.Value);
WriteLine("networkProfile");
foreach (string nicId in vm.NetworkInterfaceIds)
{
WriteLine(" networkInterface id: " + nicId);
}
WriteLine("vmAgent");
WriteLine(" vmAgentVersion" + vm.InstanceView.VmAgent.VmAgentVersion);
WriteLine(" statuses");
foreach (InstanceViewStatus stat in vm.InstanceView.VmAgent.Statuses)
{
WriteLine(" code: " + stat.Code);
WriteLine(" level: " + stat.Level);
WriteLine(" displayStatus: " + stat.DisplayStatus);
WriteLine(" message: " + stat.Message);
WriteLine(" time: " + stat.Time);
}
WriteLine("disks");
foreach (DiskInstanceView disk in vm.InstanceView.Disks)
{
WriteLine(" name: " + disk.Name);
WriteLine(" statuses");
foreach (InstanceViewStatus stat in disk.Statuses)
{
WriteLine(" code: " + stat.Code);
WriteLine(" level: " + stat.Level);
WriteLine(" displayStatus: " + stat.DisplayStatus);
WriteLine(" time: " + stat.Time);
}
}
WriteLine("VM general status");
WriteLine(" provisioningStatus: " + vm.ProvisioningState);
WriteLine(" id: " + vm.Id);
WriteLine(" name: " + vm.Name);
WriteLine(" type: " + vm.Type);
WriteLine(" location: " + vm.Region);
WriteLine("VM instance status");
foreach (InstanceViewStatus stat in vm.InstanceView.Statuses)
{
WriteLine(" code: " + stat.Code);
WriteLine(" level: " + stat.Level);
WriteLine(" displayStatus: " + stat.DisplayStatus);
}
WriteLine("Press enter to continue...");
ReadLine();
}
private static void ConfigureResources(string projectName, List <string> testAgents)
{
Configurations configurations = GetProjectConfigurations(projectName);
try
{
AzureCredentials credentials = SdkContext.AzureCredentialsFactory
.FromFile(Environment.GetEnvironmentVariable("AZURE_AUTH_LOCATION"));
IAzure azure = Azure
.Configure()
.WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic)
.Authenticate(credentials)
.WithDefaultSubscription();
foreach (var testAgent in testAgents)
{
Console.WriteLine("Creating Disks for VM: " + testAgent);
var osDiskName = testAgent + "_OSDisk";
var osDisk = azure.Disks.Define(osDiskName)
.WithRegion(region)
.WithExistingResourceGroup(configurations.ResourceGroup)
.WithWindowsFromSnapshot(configurations.OSDisksnapshot)
.WithSizeInGB(127)
.WithSku(DiskSkuTypes.PremiumLRS)
.Create();
Console.WriteLine("OS Disk created for VM: " + testAgent);
var dataDisk1Name = testAgent + "_DataDisk1";
var dataDisk1 = azure.Disks.Define(dataDisk1Name)
.WithRegion(region)
.WithExistingResourceGroup(configurations.ResourceGroup)
.WithData()
.FromSnapshot(configurations.DataDisk1Snapshot)
.WithSku(DiskSkuTypes.PremiumLRS)
.Create();
var dataDisk2Name = testAgent + "_DataDisk2";
var dataDisk2 = azure.Disks.Define(dataDisk2Name)
.WithRegion(region)
.WithExistingResourceGroup(configurations.ResourceGroup)
.WithData()
.FromSnapshot(configurations.DataDisk2Snapshot)
.WithSku(DiskSkuTypes.PremiumLRS)
.Create();
Console.WriteLine("Data disks created for VM: " + testAgent);
var networkInterface = CreateNic(azure, testAgent, configurations);
var virtualMachine = azure.VirtualMachines.Define(testAgent)
.WithRegion(region)
.WithExistingResourceGroup(configurations.ResourceGroup)
.WithExistingPrimaryNetworkInterface(networkInterface)
.WithSpecializedOSDisk(osDisk, OperatingSystemTypes.Windows)
.WithExistingDataDisk(dataDisk1, 0, CachingTypes.ReadWrite)
.WithExistingDataDisk(dataDisk2, 1, CachingTypes.ReadWrite)
.WithSize(VirtualMachineSizeTypes.StandardD8sV3)
.Create();
Console.WriteLine("Created VM: " + testAgent);
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
throw;
}
}
public static void Main(string[] args)
{
try
{
//=============================================================
// Authenticate
AzureCredentials credentials = AzureCredentials.FromFile(Environment.GetEnvironmentVariable("AZURE_AUTH_LOCATION"));
var azure = Azure
.Configure()
.WithLogLevel(HttpLoggingDelegatingHandler.Level.BASIC)
.Authenticate(credentials)
.WithDefaultSubscription();
// Print selected subscription
Console.WriteLine("Selected subscription: " + azure.SubscriptionId);
try
{
// Create a resource group [Where all resources gets created]
IResourceGroup resourceGroup = azure.ResourceGroups
.Define(rgName)
.WithRegion(Region.US_EAST)
.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.US_EAST)
.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.US_EAST)
.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();
Console.WriteLine("Creating a security group for the front ends - allows SSH and HTTP");
Console.WriteLine("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));
Console.WriteLine("Created a security group for the front end: " + frontendNSG.Id);
Utilities.PrintNetworkSecurityGroup(frontendNSG);
Console.WriteLine("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.US_EAST)
.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.US_EAST)
.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.US_EAST)
.WithExistingResourceGroup(resourceGroup)
.WithExistingPrimaryNetwork(network)
.WithSubnet("Front-end")
.WithPrimaryPrivateIpAddressDynamic()
.WithoutPrimaryPublicIpAddress()
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UBUNTU_SERVER_16_04_LTS)
.WithRootUserName(userName)
.WithPassword(password)
.WithSize(VirtualMachineSizeTypes.StandardD3V2)
.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.US_EAST)
.WithExistingResourceGroup(resourceGroup)
.WithExistingPrimaryNetwork(network)
.WithSubnet("Back-end")
.WithPrimaryPrivateIpAddressDynamic()
.WithoutPrimaryPublicIpAddress()
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UBUNTU_SERVER_16_04_LTS)
.WithRootUserName(userName)
.WithPassword(password)
.WithSize(VirtualMachineSizeTypes.StandardD3V2)
.WithNewStorageAccount(creatableStorageAccount);
backendCreatableVirtualMachines.Add(creatableVirtualMachine);
}
var startTime = DateTimeOffset.Now.UtcDateTime;
Console.WriteLine("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;
Console.WriteLine("Created virtual machines");
foreach (var virtualMachine in virtualMachines)
{
Console.WriteLine(virtualMachine.Id);
}
Console.WriteLine($"Virtual machines create: took {(endTime - startTime).TotalSeconds } seconds");
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
finally
{
Console.WriteLine($"Deleting resource group : {rgName}");
azure.ResourceGroups.Delete(rgName);
Console.WriteLine($"Deleted resource group : {rgName}");
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
static void Main(string[] args)
{
var credentials = SdkContext.AzureCredentialsFactory.FromFile("../../Credentials/authfile.json");
var azure = Azure
.Configure()
.WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic)
.Authenticate(credentials)
.WithSubscription(credentials.DefaultSubscriptionId);
var groupName = "az204_" + rng;
var vmName = "az204" + rng;
var location = "northeurope";
Console.WriteLine("Creating Resource Group...");
var resourceGroup = azure.ResourceGroups.Define(groupName)
.WithRegion(location)
.Create();
// Optionally create availability set for HA scenarios
/*
* IAvailabilitySet availabilitySet;
* Console.WriteLine("Creating availability set...");
* try
* {
* availabilitySet = azure.AvailabilitySets.Define("myAVSet")
* .WithRegion(location)
* .WithExistingResourceGroup(groupName)
* .WithSku(AvailabilitySetSkuTypes.Aligned)
* .Create();
* }
* catch (System.Threading.Tasks.TaskCanceledException e)
* {
* Console.WriteLine(e.Message);
* throw;
* }
*/
Console.WriteLine("Creating public IP address...");
var publicIPAddress = azure.PublicIPAddresses.Define("myPublicIP")
.WithRegion(location)
.WithExistingResourceGroup(groupName)
.WithDynamicIP()
.Create();
Console.WriteLine("Creating virtual network...");
var network = azure.Networks.Define("myVnet")
.WithRegion(location)
.WithExistingResourceGroup(groupName)
.WithAddressSpace("10.0.0.0/16")
.WithSubnet("mySubnet", "10.0.0.0/24")
.Create();
Console.WriteLine("Creating network interface...");
var networkInterface = azure.NetworkInterfaces.Define("myNIC")
.WithRegion(location)
.WithExistingResourceGroup(groupName)
.WithExistingPrimaryNetwork(network)
.WithSubnet("mySubnet")
.WithPrimaryPrivateIPAddressDynamic()
.WithExistingPrimaryPublicIPAddress(publicIPAddress)
.Create();
Console.WriteLine("Creating virtual machine...");
azure.VirtualMachines.Define(vmName)
.WithRegion(location)
.WithExistingResourceGroup(groupName)
.WithExistingPrimaryNetworkInterface(networkInterface)
.WithLatestWindowsImage("MicrosoftWindowsServer", "WindowsServer", "2012-R2-Datacenter")
.WithAdminUsername("azureuser")
.WithAdminPassword("Pa$$word123!")
//.WithExistingAvailabilitySet(availabilitySet)
.WithSize(VirtualMachineSizeTypes.StandardDS1V2)
.Create();
}
static void Main(string[] args)
{
//Resource details
var groupName = "rg-vm-test-westeu-1";
var vmName = "vmconsole1";
var location = Region.EuropeWest;
var vNetName = "vnet-vm-test-westeu-1";
var vNetAddress = "172.16.0.0/16";
var subnetName = "snet-vm-test-westeu-1";
var subnetAddress = "172.16.0.0/24";
var nicName = "nic-vm-westeu-1";
var adminUser = "******";
var adminPassword = "******";
var publicIPName = "pip-vm-test-westeu-1";
var nsgName = "nsg-vm-test-westeu-1";
//Creates management client
var credentials = SdkContext.AzureCredentialsFactory.FromFile("./azureAuth.properties");
var azure = Azure.Configure().WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic).Authenticate(credentials).WithDefaultSubscription();
Console.WriteLine($"Creating RG: {groupName}");
var resourceGroup = azure.ResourceGroups.Define(groupName)
.WithRegion(location)
.Create();
Console.WriteLine($"Creating VNET: {vNetName}");
var vnet = azure.Networks.Define(vNetName)
.WithRegion(location)
.WithExistingResourceGroup(groupName)
.WithAddressSpace(vNetAddress)
.WithSubnet(subnetName, subnetAddress)
.Create();
// Optional
Console.WriteLine($"Creating PIP: {publicIPName}");
var pip = azure.PublicIPAddresses.Define(publicIPName)
.WithRegion(location)
.WithExistingResourceGroup(groupName)
.Create();
// Optional
Console.WriteLine($"Creating NSG: {nsgName}");
var nsg = azure.NetworkSecurityGroups.Define(nsgName)
.WithRegion(location)
.WithExistingResourceGroup(groupName)
.Create();
// Optional
Console.WriteLine($"Creating sec rule: Allow RDP");
nsg.Update()
.DefineRule("Allow-RDP")
.AllowInbound()
.FromAnyAddress()
.FromAnyPort()
.ToAnyAddress()
.ToPort(3389)
.WithProtocol(SecurityRuleProtocol.Tcp)
.WithPriority(100)
.WithDescription("Allow-RDP")
.Attach()
.Apply();
Console.WriteLine($"Creating NIC: {nicName}");
var nic = azure.NetworkInterfaces.Define(nicName)
.WithRegion(location)
.WithExistingResourceGroup(groupName)
.WithExistingPrimaryNetwork(vnet)
.WithSubnet(subnetName)
.WithPrimaryPrivateIPAddressDynamic()
// Optional
.WithExistingPrimaryPublicIPAddress(pip)
.WithExistingNetworkSecurityGroup(nsg)
//
.Create();
Console.WriteLine($"Creating VM: {vmName}");
var vm = azure.VirtualMachines.Define(vmName)
.WithRegion(location)
.WithExistingResourceGroup(groupName)
.WithExistingPrimaryNetworkInterface(nic)
.WithLatestWindowsImage("MicrosoftWindowsServer", "WindowsServer", "2012-R2-Datacenter")
.WithAdminUsername(adminUser)
.WithAdminPassword(adminPassword)
.WithComputerName(vmName)
.WithSize(VirtualMachineSizeTypes.StandardDS2V2)
.Create();
}
static void Main(string[] args)
{
// The file with the Azure Service Principal Credentials.
var authFile = "my.azureauth";
// Parse the credentials from the file.
var credentials = SdkContext.AzureCredentialsFactory.FromFile(authFile);
// Authenticate with Azure
var azure = Azure
.Configure()
.Authenticate(credentials)
.WithDefaultSubscription();
// Create an InsightsClient instance.
var client = new InsightsClient(credentials);
// If we subscription is not set the API call will fail.
client.SubscriptionId = credentials.DefaultSubscriptionId;
// Create the OData filter for a time interval and the Azure.Health Provider.
// Search back one day.
var days = -1;
var endDateTime = DateTime.Now;
var startDateTime = endDateTime.AddDays(days);
string filterString = FilterString.Generate <EventDataForFilter>(eventData =>
(eventData.EventTimestamp >= startDateTime) &&
(eventData.EventTimestamp <= endDateTime) &&
(eventData.ResourceProvider == "Azure.Health"));
// Get the Events from Azure.
var response = client.Events.List(filterString);
while (response != null && response.Any())
{
foreach (var eventData in response)
{
// Set the Console Color according to the Event Status.
if (eventData.Status.Value != "Resolved" &&
eventData.Level <= EventLevel.Warning)
{
Console.ForegroundColor = ConsoleColor.Red;
}
else if (eventData.Status.Value == "Resolved")
{
Console.ForegroundColor = ConsoleColor.Green;
}
else
{
Console.ForegroundColor = ConsoleColor.White;
}
// Write event data to the console
Console.WriteLine($"{eventData.EventTimestamp.ToLocalTime()} - {eventData.ResourceProviderName.Value} - {eventData.OperationName.Value}");
Console.WriteLine($"Status:\t {eventData.Status.Value}");
Console.WriteLine($"Level:\t {eventData.Level.ToString()}");
Console.WriteLine($"CorrelationId:\t {eventData.CorrelationId}");
Console.WriteLine($"Resource Type:\t {eventData.ResourceType.Value}");
Console.WriteLine($"Description:\t {eventData.Description}");
}
// Get more events if available.
if (!string.IsNullOrEmpty(response.NextPageLink))
{
response = client.Events.ListNext(response.NextPageLink);
}
else
{
response = null;
}
}
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("No more events...");
Console.ForegroundColor = ConsoleColor.White;
}
public static void Run([TimerTrigger("0 0 */6 * * *", RunOnStartup = true)] TimerInfo myTimer, ILogger logger, ExecutionContext context)
{
logger.LogInformation($"C# Timer trigger function starting at: {DateTime.UtcNow}");
IConfigurationRoot config = new ConfigurationBuilder()
.SetBasePath(context.FunctionAppDirectory)
.AddJsonFile("local.settings.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables()
.Build();
var isEnabled = config["IsEnabled"];
if (isEnabled != null && isEnabled.Equals(Boolean.FalseString))
{
logger.LogInformation("Function not enabled");
return;
}
var tenantId = config["TenantId"];
var exceptedRGsRegex = config["Exceptions"];
var environment = AzureEnvironment.AzureGlobalCloud;
AzureCredentials credentials;
var isRunningLocally = config["IsRunningLocally"];
if (isRunningLocally != null && isRunningLocally.Equals(Boolean.TrueString))
{
var clientId = config["ClientId"];
var clientSecret = config["ClientSecret"];
credentials = SdkContext.AzureCredentialsFactory.FromServicePrincipal(clientId, clientSecret, tenantId, environment);
}
else
{
credentials = SdkContext.AzureCredentialsFactory.FromMSI(new MSILoginInformation(MSIResourceType.AppService), AzureEnvironment.AzureGlobalCloud);
}
var authenticated = Azure
.Configure()
.WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic)
.Authenticate(credentials);
foreach (var subscriptionId in config["Subscriptions"].Split(',', StringSplitOptions.RemoveEmptyEntries))
{
try
{
var subCleaner = new AzureSubscriptionCleaner(authenticated, subscriptionId, exceptedRGsRegex, logger, config);
using (logger.BeginScope(
new Dictionary <string, object>
{
[nameof(subscriptionId)] = subscriptionId
})
)
{
subCleaner.ProcessSubscription();
}
}
catch (Exception ex)
{
logger.LogError(
$"Exception occured while processing the subscription: {Environment.NewLine} {ex}");
}
}
logger.LogInformation($"C# Timer trigger function finishing at: {DateTime.Now}");
}
public IAzure GetClient() => Azure.Configure() .WithLogLevel(HttpLoggingDelegatingHandler.Level.BodyAndHeaders) .Authenticate(_credentials).WithDefaultSubscription();
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 async Task <Azure.IAuthenticated> GetAzureConnection()
{
if (_azure != null)
{
return(_azure);
}
AzureCredentials credentials;
string localDevelopment = Environment.GetEnvironmentVariable("LocalDevelopment", EnvironmentVariableTarget.Process);
if (!string.IsNullOrEmpty(localDevelopment) &&
string.Equals(localDevelopment, "true", StringComparison.InvariantCultureIgnoreCase))
{
Log.LogDebug($"Get the local service principal for local login");
var localDevSp = new Principal
{
UserPrincipalName = "LocalLogin",
AppId = Environment.GetEnvironmentVariable("ClientId", EnvironmentVariableTarget.Process),
TenantId = Environment.GetEnvironmentVariable("TenantId", EnvironmentVariableTarget.Process)
};
string clientSecret = Environment.GetEnvironmentVariable("ClientSecret", EnvironmentVariableTarget.Process);
Log.LogDebug($"AppId: {localDevSp.AppId}, TenantId: {localDevSp.TenantId}");
credentials = SdkContext
.AzureCredentialsFactory
.FromServicePrincipal(localDevSp.AppId, clientSecret, localDevSp.TenantId, AzureEnvironment.AzureGlobalCloud);
}
else
{
Log.LogDebug($"Get the MSI credentials");
// Because MSI isn't really nicely supported in this nuget package disable it for now and user workaround
////credentials = SdkContext
//// .AzureCredentialsFactory
//// .FromMSI(new MSILoginInformation(MSIResourceType.AppService), AzureEnvironment.AzureGlobalCloud);
try
{
// START workaround until MSI in this package is really supported
string tenantId = Environment.GetEnvironmentVariable("TenantId", EnvironmentVariableTarget.Process);
Log.LogDebug($"TenantId: {tenantId}");
AzureServiceTokenProvider astp = new AzureServiceTokenProvider();
string graphToken = await astp.GetAccessTokenAsync("https://graph.windows.net/", tenantId);
AzureServiceTokenProvider astp2 = new AzureServiceTokenProvider();
string rmToken = await astp2.GetAccessTokenAsync("https://management.azure.com/", tenantId);
Log.LogDebug("Logging with tokens from Token Provider");
AzureCredentials customTokenProvider = new AzureCredentials(
new TokenCredentials(rmToken),
new TokenCredentials(graphToken),
tenantId,
AzureEnvironment.AzureGlobalCloud);
RestClient client = RestClient
.Configure()
.WithEnvironment(AzureEnvironment.AzureGlobalCloud)
.WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic)
//.WithRetryPolicy(new RetryPolicy(new HttpStatusCodeErrorDetectionStrategy(), new IncrementalRetryStrategy(2, TimeSpan.FromSeconds(30), TimeSpan.FromMinutes(1))))
.WithCredentials(customTokenProvider)
.Build();
return(Azure.Authenticate(client, tenantId));
// END workaround until MSI in this package is really supported
}
catch (Exception ex)
{
Log.LogError(ex, ex.Message);
if (ex.InnerException != null)
{
Log.LogError(ex.InnerException, ex.InnerException.Message);
}
throw;
}
}
ServiceClientTracing.AddTracingInterceptor(new MicrosoftExtensionsLoggingTracer(Log));
ServiceClientTracing.IsEnabled = true;
_azure = Azure
.Configure()
.WithDelegatingHandler(new HttpLoggingDelegatingHandler())
.WithLogLevel(HttpLoggingDelegatingHandler.Level.None)
.Authenticate(credentials);
return(_azure);
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
ILogger log)
{
var subscriptionId = System.Environment.GetEnvironmentVariable("SUBSCRIPTION_ID", EnvironmentVariableTarget.Process);
string COUNT = req.Query["COUNT"];
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
dynamic data = JsonConvert.DeserializeObject(requestBody);
COUNT = COUNT ?? data?.COUNT;
string TYPE = req.Query["TYPE"];
string requestBody1 = await new StreamReader(req.Body).ReadToEndAsync();
dynamic data1 = JsonConvert.DeserializeObject(requestBody);
TYPE = TYPE ?? data?.TYPE;
int ftdCountInt = Convert.ToInt32(COUNT);
int index = 1;
if ("REGULAR" == TYPE)
{
log.LogWarning("GetFtdPublicIp:::: This is regular scale-out ");
}
else if ("INIT" == TYPE)
{
log.LogWarning("GetFtdPublicIp:::: This is initial deployment");
}
else
{
return((ActionResult) new BadRequestObjectResult("ERROR: Invalid request TYPE"));
}
var resoureGroupName = System.Environment.GetEnvironmentVariable("RESOURCE_GROUP_NAME", EnvironmentVariableTarget.Process);
var vmScalesetName = System.Environment.GetEnvironmentVariable("VMSS_NAME", EnvironmentVariableTarget.Process);
var networkInterfaceName = System.Environment.GetEnvironmentVariable("MNGT_NET_INTERFACE_NAME", EnvironmentVariableTarget.Process);
var ipConfigurationName = System.Environment.GetEnvironmentVariable("MNGT_IP_CONFIG_NAME", EnvironmentVariableTarget.Process);
var publicIpAddressName = System.Environment.GetEnvironmentVariable("MNGT_PUBLIC_IP_NAME", EnvironmentVariableTarget.Process);
log.LogWarning("GetFtdPublicIp:::: Getting Public IP of new FTD (RG : {0}, VMSS: {1} )", resoureGroupName.ToString(), vmScalesetName.ToString());
log.LogInformation("GetFtdPublicIp:::: Network Interface name : {0}, IP Configuration Name : {1}, Public IP Address Name : {2}", networkInterfaceName, ipConfigurationName, publicIpAddressName);
var factory = new AzureCredentialsFactory();
var msiCred = factory.FromMSI(new MSILoginInformation(MSIResourceType.AppService), AzureEnvironment.AzureGlobalCloud);
var azure = Azure.Configure().WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic).Authenticate(msiCred).WithSubscription(subscriptionId);
var NmClient = new NetworkManagementClient(msiCred)
{
SubscriptionId = azure.SubscriptionId
};
var interfaceList = NmClient.NetworkInterfaces.ListVirtualMachineScaleSetNetworkInterfaces(resoureGroupName, vmScalesetName);
string vmindex = "";
string tmpVmindex = "";
int intVmindex = 0;
var vmlist = azure.VirtualMachineScaleSets.GetByResourceGroup(resoureGroupName, vmScalesetName);
var vmStatus = "";
var tmpVmName = "ERROR";
//ToDo: This logic should be simplified by only using VMSS list, netInterface is not needed
foreach (var netInterface in interfaceList)
{
if (netInterface.IpConfigurations[0].PublicIPAddress != null)
{
var tmpIntfName = netInterface.IpConfigurations[0].PublicIPAddress.Id.Split('/').GetValue(12);
var tmpConfigName = netInterface.IpConfigurations[0].PublicIPAddress.Id.Split('/').GetValue(14);
var tmpPubIpName = netInterface.IpConfigurations[0].PublicIPAddress.Id.Split('/').GetValue(16);
if ((tmpIntfName.ToString() == networkInterfaceName) && (tmpConfigName.ToString() == ipConfigurationName) && (tmpPubIpName.ToString() == publicIpAddressName))
{
vmindex = netInterface.IpConfigurations[0].PublicIPAddress.Id.Split('/').GetValue(10).ToString();
//Azure bug: Azure sometimes retains old deleted VMs in its list for very long time, need to avoid those instances
vmStatus = "ON";
foreach (var vm in vmlist.VirtualMachines.List())
{
if (vm.InstanceId == vmindex)
{
if (null == vm.PowerState)
{
vmStatus = "OFF";
}
if (null != vm.Name)
{
tmpVmName = vm.Name;
}
break;
}
}
if ("OFF" == vmStatus)
{
log.LogError("GetFtdPublicIp:::: VM index :{0} is in unknown state..skip", vmindex);
continue;
}
//Azure bug: some times even deleted VMs are still attahed to network interfaces for very long time
if ("ERROR" == tmpVmName)
{
log.LogError("GetFtdPublicIp:::: VM index :{0} VM name not found...skip", vmindex);
continue;
}
if ("INIT" == TYPE)
{
if (index == ftdCountInt)
{
//index >100 is just to safegaurd this loop..its has no other logic
break;
}
index++;
}
else
{
//Azure bug: Some time it will mix indexes and does not preserve sequence
if (Convert.ToInt32(vmindex) < intVmindex)
{
log.LogWarning("GetFtdPublicIp:::: Azure index jumbling detected");
vmindex = intVmindex.ToString();
}
else
{
intVmindex = Convert.ToInt32(vmindex);
log.LogInformation("GetFtdPublicIp:::: Assigning vmindex = {0}", vmindex);
}
}
}
}
}
var publicIp = NmClient.PublicIPAddresses.GetVirtualMachineScaleSetPublicIPAddress(resoureGroupName, vmScalesetName, vmindex, networkInterfaceName, ipConfigurationName, publicIpAddressName).IpAddress;
if (null == publicIp)
{
log.LogError("GetFtdPublicIp:::: Unable to get Public IP of new FTD (index {0}", vmindex);
return((ActionResult) new BadRequestObjectResult("ERROR: Unable to get Public IP of new FTD"));
}
log.LogInformation("GetFtdPublicIp:::: Public IP of New FTD (VM index {0}) = {1}", vmindex, publicIp);
//find VM name from index
string vmname = "";
string privateIp = "";
var vmss = azure.VirtualMachineScaleSets.GetByResourceGroup(resoureGroupName, vmScalesetName);
foreach (var vm in vmss.VirtualMachines.List())
{
if (vm.InstanceId == vmindex)
{
vmname = vm.Name;
foreach (var netintf in vm.ListNetworkInterfaces())
{
privateIp = netintf.PrimaryPrivateIP;
break;
}
break;
}
}
var commandStr = "{ \"ftdDevName\": \"" + vmname + "\", \"ftdPublicIp\": \"" + publicIp + "\", \"ftdPrivateIp\" : \"" + privateIp + "\" }";
return((ActionResult) new OkObjectResult(commandStr));
}
public static void Main(string[] args)
{
try
{
//=================================================================
// Authenticate
AzureCredentials credentials = AzureCredentials.FromFile(Environment.GetEnvironmentVariable("AZURE_AUTH_LOCATION"));
var azure = Azure
.Configure()
.WithLogLevel(HttpLoggingDelegatingHandler.Level.BASIC)
.Authenticate(credentials)
.WithDefaultSubscription();
// Print selected subscription
Console.WriteLine("Selected subscription: " + azure.SubscriptionId);
try
{
// ===========================================================
// Get how many batch accounts can be created in specified region.
int allowedNumberOfBatchAccounts = azure.BatchAccounts.GetBatchAccountQuotaByLocation(region);
// ===========================================================
// List all the batch accounts in subscription.
var batchAccounts = azure.BatchAccounts.List();
int batchAccountsAtSpecificRegion = batchAccounts.Count(x => x.Region == region);
if (batchAccountsAtSpecificRegion >= allowedNumberOfBatchAccounts)
{
Console.WriteLine("No more batch accounts can be created at "
+ region + " region, this region already have "
+ batchAccountsAtSpecificRegion
+ " batch accounts, current quota to create batch account in "
+ region + " region is " + allowedNumberOfBatchAccounts + ".");
return;
}
// ============================================================
// Create a batch account
Console.WriteLine("Creating a batch Account");
var batchAccount = azure.BatchAccounts.Define(batchAccountName)
.WithRegion(region)
.WithNewResourceGroup(rgName)
.DefineNewApplication(applicationName)
.DefineNewApplicationPackage(applicationPackageName)
.WithAllowUpdates(true)
.WithDisplayName(applicationDisplayName)
.Attach()
.WithNewStorageAccount(storageAccountName)
.Create();
Console.WriteLine("Created a batch Account:");
Utilities.PrintBatchAccount(batchAccount);
// ============================================================
// Get | regenerate batch account access keys
Console.WriteLine("Getting batch account access keys");
var batchAccountKeys = batchAccount.GetKeys();
Utilities.PrintBatchAccountKey(batchAccountKeys);
Console.WriteLine("Regenerating primary batch account primary access key");
batchAccountKeys = batchAccount.RegenerateKeys(AccountKeyType.Primary);
Utilities.PrintBatchAccountKey(batchAccountKeys);
// ============================================================
// Regenerate the keys for storage account
var storageAccount = azure.StorageAccounts.GetByGroup(rgName, storageAccountName);
var storageAccountKeys = storageAccount.GetKeys();
Utilities.PrintStorageAccountKeys(storageAccountKeys);
Console.WriteLine("Regenerating first storage account access key");
storageAccountKeys = storageAccount.RegenerateKey(storageAccountKeys[0].KeyName);
Utilities.PrintStorageAccountKeys(storageAccountKeys);
// ============================================================
// Synchronize storage account keys with batch account
batchAccount.SynchronizeAutoStorageKeys();
// ============================================================
// Update name of application.
batchAccount
.Update()
.UpdateApplication(applicationName)
.WithDisplayName("New application display name")
.Parent()
.Apply();
batchAccount.Refresh();
Utilities.PrintBatchAccount(batchAccount);
// ============================================================
// Create another batch account
Console.WriteLine("Creating another Batch Account");
allowedNumberOfBatchAccounts = azure.BatchAccounts.GetBatchAccountQuotaByLocation(region2);
// ===========================================================
// List all the batch accounts in subscription.
batchAccounts = azure.BatchAccounts.List();
batchAccountsAtSpecificRegion = batchAccounts.Count(x => x.Region == region2);
IBatchAccount batchAccount2 = null;
if (batchAccountsAtSpecificRegion < allowedNumberOfBatchAccounts)
{
batchAccount2 = azure.BatchAccounts.Define(batchAccountName2)
.WithRegion(region2)
.WithExistingResourceGroup(rgName)
.WithExistingStorageAccount(storageAccount)
.Create();
Console.WriteLine("Created second Batch Account:");
Utilities.PrintBatchAccount(batchAccount2);
}
// ============================================================
// List batch accounts
Console.WriteLine("Listing Batch accounts");
var accounts = azure.BatchAccounts.ListByGroup(rgName);
IBatchAccount ba;
foreach (var account in accounts)
{
Console.WriteLine("Batch Account - " + account.Name);
}
// ============================================================
// Refresh a batch account.
batchAccount.Refresh();
Utilities.PrintBatchAccount(batchAccount);
// ============================================================
// Delete a batch account
Console.WriteLine("Deleting a batch account - " + batchAccount.Name);
foreach (var applicationEntry in batchAccount.Applications)
{
foreach (var applicationPackageEntry in applicationEntry.Value.ApplicationPackages)
{
Console.WriteLine("Deleting a application package - " + applicationPackageEntry.Key);
applicationPackageEntry.Value.Delete();
}
Console.WriteLine("Deleting a application - " + applicationEntry.Key);
batchAccount.Update().WithoutApplication(applicationEntry.Key).Apply();
}
try
{
azure.BatchAccounts.Delete(batchAccount.Id);
}
catch
{
}
Console.WriteLine("Deleted batch account");
if (batchAccount2 != null)
{
Console.WriteLine("Deleting second batch account - " + batchAccount2.Name);
try
{
azure.BatchAccounts.Delete(batchAccount2.Id);
}
catch
{
}
Console.WriteLine("Deleted second batch account");
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
finally
{
try
{
Console.WriteLine("Deleting Resource Group: " + rgName);
azure.ResourceGroups.Delete(rgName);
Console.WriteLine("Deleted Resource Group: " + rgName);
}
catch (Exception)
{
Console.WriteLine("Did not create any resources in Azure. No clean up is necessary");
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req,
ILogger log)
{
try
{
log.LogInformation("Getting request body params");
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
dynamic data = JsonConvert.DeserializeObject(requestBody);
string subscriptionId = data?.subscriptionId;
string resourceGroupName = data?.resourceGroupName;
bool? useVmStartAwait = data?.wait;
string vmName = data?.vmName;
if (subscriptionId == null || resourceGroupName == null || vmName == null)
{
return(new BadRequestObjectResult("Please pass all 3 required parameters in the request body"));
}
if (useVmStartAwait == null)
{
useVmStartAwait = false;
}
log.LogInformation("Setting authentication to use MSI");
AzureCredentialsFactory f = new AzureCredentialsFactory();
var msi = new MSILoginInformation(MSIResourceType.AppService);
var msiCred = f.FromMSI(msi, AzureEnvironment.AzureGlobalCloud);
var azureAuth = Azure.Configure()
.WithLogLevel(HttpLoggingDelegatingHandler.Level.BodyAndHeaders)
.Authenticate(msiCred);
log.LogInformation("Authenticating with Azure using MSI");
var azure = azureAuth.WithSubscription(subscriptionId);
log.LogInformation("Acquiring VM from Azure");
var vm = azure.VirtualMachines.GetByResourceGroup(resourceGroupName, vmName);
log.LogInformation("Checking VM Id");
log.LogInformation(vm.Id.ToString());
log.LogInformation("Checking VM Powerstate");
log.LogInformation("VM Powerstate : " + vm.PowerState.ToString());
bool vmStarting = false;
if (vm.PowerState.ToString() == "PowerState/running")
{
log.LogInformation("VM is already running");
}
else
{
if (useVmStartAwait.Value)
{
log.LogInformation("Async Starting vm " + vmName);
await vm.StartAsync();
}
else
{
log.LogInformation("Sync Starting vm " + vmName);
vm.Start();
}
vmStarting = true;
}
return(vmStarting == false
? (ActionResult) new OkObjectResult("VM was already started")
: (ActionResult) new OkObjectResult("VM started"));
}
catch (System.Exception ex)
{
log.LogError(ex.Message);
throw;
}
}
public UserContext(Principal principal)
{
this.Principal = principal;
var loginSettings = new ActiveDirectoryServiceSettings
{
AuthenticationEndpoint = Configuration.AuthorizationEndpoint,
TokenAudience = new Uri("https://management.core.windows.net/")
};
this.ClientCredentials = ApplicationTokenProvider.LoginSilentAsync(
this.Principal.TenantId,
new ClientCredential(this.Principal.ClientId, this.Principal.Secret),
loginSettings).Result;
this.AzureCredentials = SdkContext.AzureCredentialsFactory.FromServicePrincipal(
this.Principal.ClientId,
this.Principal.Secret,
this.Principal.TenantId,
AzureEnvironment.AzureGlobalCloud);
this.AzureClient = Azure.Configure().Authenticate(this.AzureCredentials)
.WithSubscription(principal.SubscriptionId);
this.DataShareClient =
new DataShareManagementClient(Configuration.ArmEndpoint, this.ClientCredentials)
{
SubscriptionId = principal.SubscriptionId
};
if (string.IsNullOrWhiteSpace(this.Principal.DataShareResourceGroup))
{
this.Principal.DataShareResourceGroup = UserContext.GenerateName();
}
if (string.IsNullOrWhiteSpace(this.Principal.DataShareAccountName))
{
this.Principal.DataShareAccountName = UserContext.GenerateName();
}
if (string.IsNullOrWhiteSpace(this.Principal.DataShareShareName))
{
this.Principal.DataShareShareName = UserContext.GenerateName();
}
if (string.IsNullOrWhiteSpace(this.Principal.DataShareInvitation))
{
this.Principal.DataShareInvitation = UserContext.GenerateName();
}
if (string.IsNullOrWhiteSpace(this.Principal.DataShareShareSubscriptionName))
{
this.Principal.DataShareShareSubscriptionName = UserContext.GenerateName();
}
if (string.IsNullOrWhiteSpace(this.Principal.DataShareDataSetName))
{
this.Principal.DataShareDataSetName = UserContext.GenerateName();
}
if (string.IsNullOrWhiteSpace(this.Principal.DataShareDataSetMappingName))
{
this.Principal.DataShareDataSetMappingName = UserContext.GenerateName();
}
}
public static async void Run([TimerTrigger("0 */5 * * * *")] TimerInfo myTimer, ILogger log)
{
log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");
HttpClient client = new HttpClient();
/*
* The Documentation for the Office APIs specifies that each request requires an ID which is just a generated GUID.
* https://docs.microsoft.com/en-us/Office365/Enterprise/office-365-ip-web-service#common-parameters
*/
Guid requestId = Guid.NewGuid();
// Building the URL
var url = @"https://endpoints.office.com/endpoints/worldwide?clientrequestid=" + requestId;
// Requesting the API
var response = await client.GetAsync(url);
var officeAPIsAsJson = await response.Content.ReadAsStringAsync();
// Lazy People don't like Objects...
dynamic officeEndpoints = JsonConvert.DeserializeObject(officeAPIsAsJson);
#region PreppingStructure
/// Everything in here is just to create a List of Objects that contain everything we need to make a rule. (IPs, Name, tcp or udp, required)
var rules = new List <RuleSet>();
foreach (dynamic endpoint in officeEndpoints)
{
string ports = "";
bool tcp = true;
if (endpoint.tcpPorts != null)
{
ports = endpoint.tcpPorts;
}
else
{
ports = endpoint.udpPorts;
tcp = false;
}
if (endpoint.ips != null)
{
foreach (string ip in endpoint.ips)
{
RuleSet rs = new RuleSet
{
Name = endpoint.serviceAreaDisplayName,
IpRange = ip,
PortRange = ports,
IsTCP = tcp,
Required = endpoint.required
};
rules.Add(rs);
log.LogInformation($"Adding RuleSet for IP Range: {rs.IpRange} - {rs.Name}");
}
}
}
#endregion
//Now Azure
//The Function need to have a system assigned managed identity.
//Follow the first step here to create one: https://www.azurecorner.com/using-managed-service-identity-in-azure-functions-to-access-azure-sql-database/
//Next you need to give a Role Assignment on the target Resources/Resourcegroup to the Function App (I chose "Creator", but other more specialized role might fit better)
//Getting the credentials for the Managed Service Identity
var creds = SdkContext.AzureCredentialsFactory.FromSystemAssignedManagedServiceIdentity(Microsoft.Azure.Management.ResourceManager.Fluent.Authentication.MSIResourceType.AppService, AzureEnvironment.AzureGlobalCloud);
//"Connecting" to Azure.
var azure = Azure
.Configure()
.WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic)
.Authenticate(creds)
.WithDefaultSubscription();
//Getting the existing NSG. If there is only one NSG per Resource Group you could probably also use GetBy..Group..
var nsg = await azure.NetworkSecurityGroups.GetByIdAsync("/subscriptions/5becef9c-f620-40ef-9b8b-bff338e19893/resourceGroups/berndfunction/providers/Microsoft.Network/networkSecurityGroups/myNSG");
var update = nsg.Update();
int prio = 200;
Random r = new Random();
foreach (var rule in rules)
{
try
{
var ruleName = rule.Name;
ruleName += r.Next();
update.DefineRule(ruleName)
.AllowInbound()
.FromAddress(rule.IpRange)
.FromAnyPort()
.ToAnyAddress()
.ToAnyPort()
.WithProtocol(rule.IsTCP ? SecurityRuleProtocol.Tcp : SecurityRuleProtocol.Udp)
.WithPriority(prio)
.WithDescription($"{rule.Name} is Required: {rule.Required}")
.Attach()
.DefineRule(ruleName)
.AllowOutbound()
.FromAnyAddress()
.FromAnyPort()
.ToAddress(rule.IpRange)
.ToAnyPort()
.WithProtocol(rule.IsTCP ? SecurityRuleProtocol.Tcp : SecurityRuleProtocol.Udp)
.WithPriority(prio)
.WithDescription($"{rule.Name} is Required: {rule.Required}")
.Attach();
log.LogInformation($"NSG Rule defined for: {rule.Name}");
prio += 5;
}
catch (Exception ex)
{
log.LogInformation($"Exception for: {ex.Message}");
throw;
}
}
log.LogInformation($"Applying NSG Rules");
try
{
var result = await update.ApplyAsync();
}
catch (Exception ex)
{
log.LogInformation($"Exception for: {ex.Message}");
throw;
}
Console.WriteLine("Hello World!");
}
public static void Main(string[] args)
{
try
{
//=============================================================
// Authenticate
AzureCredentials credentials = AzureCredentials.FromFile(Environment.GetEnvironmentVariable("AZURE_AUTH_LOCATION"));
var azure = Azure
.Configure()
.WithLogLevel(HttpLoggingDelegatingHandler.Level.BASIC)
.Authenticate(credentials)
.WithDefaultSubscription();
// Print selected subscription
Console.WriteLine("Selected subscription: " + azure.SubscriptionId);
try
{
// Create a resource group [Where all resources gets created]
IResourceGroup resourceGroup = azure.ResourceGroups
.Define(rgName)
.WithRegion(Region.US_EAST)
.Create();
// Prepare Creatable Network definition [Where all the virtual machines get added to]
var creatableNetwork = azure.Networks
.Define(networkName)
.WithRegion(Region.US_EAST)
.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.US_EAST)
.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.US_EAST)
.WithExistingResourceGroup(resourceGroup)
.WithNewPrimaryNetwork(creatableNetwork)
.WithPrimaryPrivateIpAddressDynamic()
.WithoutPrimaryPublicIpAddress()
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UBUNTU_SERVER_16_04_LTS)
.WithRootUserName("tirekicker")
.WithPassword("12NewPA$$w0rd!")
.WithSize(VirtualMachineSizeTypes.StandardD3V2)
.WithNewStorageAccount(creatableStorageAccount);
creatableVirtualMachines.Add(creatableVirtualMachine);
}
var startTime = DateTimeOffset.Now.UtcDateTime;
Console.WriteLine("Creating the virtual machines");
Console.WriteLine("Created virtual machines");
var virtualMachines = azure.VirtualMachines.Create(creatableVirtualMachines.ToArray());
foreach (var virtualMachine in virtualMachines)
{
Console.WriteLine(virtualMachine.Id);
}
var endTime = DateTimeOffset.Now.UtcDateTime;
Console.WriteLine($"Created VM: took {(endTime - startTime).TotalSeconds} seconds");
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
finally
{
Console.WriteLine($"Deleting resource group : {rgName}");
azure.ResourceGroups.Delete(rgName);
Console.WriteLine($"Deleted resource group : {rgName}");
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
{ static void Main(string[] args)
{
Console.WriteLine("Starting Deployment");
// Get Azure credentials
var credentials = SdkContext.AzureCredentialsFactory
.FromFile("./azureauth.properties");
// Authenticate to Azure
var azure = Azure
.Configure()
.WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic)
.Authenticate(credentials)
.WithDefaultSubscription();
//create required variables
var groupName = "az204-ResourceGroup2";
var vmName = "WinVM";
var location = Region.USEast;
var vNetName = "az204VNET";
var vNetAddress = "10.10.0.0/16";
var subnetName = "az204Subnet";
var subnetAddress = "10.10.0.0/24";
var nicName = "az204NIC";
var adminUser = "******";
var adminPassword = "******";
Console.WriteLine($"It is time to create the resource group {groupName} ...");
var resourceGroup = azure.ResourceGroups.Define(groupName)
.WithRegion(location)
.Create();
Console.WriteLine($"It is time to create the virtual network {vNetName} ...");
var network = azure.Networks.Define(vNetName)
.WithRegion(location)
.WithExistingResourceGroup(groupName)
.WithAddressSpace(vNetAddress)
.WithSubnet(subnetName, subnetAddress)
.Create();
Console.WriteLine($"It is time to creating network interface {nicName} ...");
var nic = azure.NetworkInterfaces.Define(nicName)
.WithRegion(location)
.WithExistingResourceGroup(groupName)
.WithExistingPrimaryNetwork(network)
.WithSubnet(subnetName)
.WithPrimaryPrivateIPAddressDynamic()
.Create();
Console.WriteLine($"Creating virtual machine {vmName} ...");
azure.VirtualMachines.Define(vmName)
.WithRegion(location)
.WithExistingResourceGroup(groupName)
.WithExistingPrimaryNetworkInterface(nic)
.WithLatestWindowsImage("MicrosoftWindowsServer", "WindowsServer", "2012-R2-Datacenter")
.WithAdminUsername(adminUser)
.WithAdminPassword(adminPassword)
.WithComputerName(vmName)
.WithSize(VirtualMachineSizeTypes.StandardDS2V2)
.Create();
}
public static async Task Main(string[] args)
{
IConfigurationBuilder builder = new ConfigurationBuilder().SetBasePath(Directory.GetCurrentDirectory()).AddUserSecrets <ManagementExample>();
IConfigurationRoot configuration = builder.Build();
IConfigurationSection c = configuration.GetSection("ManagementExample");
IConfigurationSection clientId = c.GetSection("ClientId");
IConfigurationSection clientSecret = c.GetSection("ClientSecret");
IConfigurationSection tenantId = c.GetSection("TenantId");
AzureCredentials credentials = SdkContext.AzureCredentialsFactory.FromServicePrincipal(clientId.Value, clientSecret.Value, tenantId.Value, AzureEnvironment.AzureGlobalCloud);
IAzure azure = Azure
.Configure()
.WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic)
.Authenticate(credentials)
.WithDefaultSubscription();
string rgName = SdkContext.RandomResourceName("test_", 4);
try
{
// List resource groups
Console.WriteLine("Resource Groups:");
IPagedCollection <IResourceGroup> rgs = await azure.ResourceGroups.ListAsync();
if (rgs.Any())
{
foreach (IResourceGroup l in rgs)
{
Console.WriteLine($"-- {l.Name}");
}
}
else
{
Console.WriteLine("-- No Resource Groups");
}
// Create resource group
await azure.ResourceGroups
.Define(rgName)
.WithRegion(Region.USWest)
.CreateAsync();
Console.WriteLine($"Created Resource Group: {rgName}");
// Create storage account.
string saName = SdkContext.RandomResourceName("test", 4);
await azure.StorageAccounts
.Define(saName)
.WithRegion(Region.USWest)
.WithExistingResourceGroup(rgName)
.CreateAsync();
Console.WriteLine($"Created Storage Account: {saName}");
Console.WriteLine();
Console.WriteLine("Press any key to delete all resource groups...");
Console.ReadLine();
}
catch (Exception exception)
{
Console.WriteLine($"Exception: {exception.Message}");
}
finally
{
try
{
// Delete all resource groups
Console.WriteLine($"Deleting Resource Groups:");
foreach (IResourceGroup l in await azure.ResourceGroups.ListAsync())
{
await azure.ResourceGroups.DeleteByNameAsync(l.Name);
Console.WriteLine($"-- {rgName} DELETED");
}
}
catch (Exception exception)
{
Console.WriteLine($"Exception: {exception.Message}");
}
}
Console.ReadLine();
}
public static void Main(string[] args)
{
try
{
//=================================================================
// Authenticate
AzureCredentials credentials = AzureCredentials.FromFile(Environment.GetEnvironmentVariable("AZURE_AUTH_LOCATION"));
var azure = Azure
.Configure()
.WithLogLevel(HttpLoggingDelegatingHandler.Level.BASIC)
.Authenticate(credentials)
.WithDefaultSubscription();
//=================================================================
// List all virtual machine image publishers and
// list all virtual machine images
// published by Canonical, Red Hat and SUSE
// by browsing through locations, publishers, offers, SKUs and images
var publishers = azure
.VirtualMachineImages
.Publishers
.ListByRegion(Region.US_EAST);
Console.WriteLine("US East data center: printing list of \n"
+ "a) Publishers and\n"
+ "b) Images published by Canonical, Red Hat and Suse");
Console.WriteLine("=======================================================");
Console.WriteLine("\n");
foreach (var publisher in publishers)
{
Console.WriteLine("Publisher - " + publisher.Name);
if (StringComparer.OrdinalIgnoreCase.Equals(publisher.Name, "Canonical") ||
StringComparer.OrdinalIgnoreCase.Equals(publisher.Name, "Suse") ||
StringComparer.OrdinalIgnoreCase.Equals(publisher.Name, "RedHat"))
{
Console.WriteLine("\n\n");
Console.WriteLine("=======================================================");
Console.WriteLine("Located " + publisher.Name);
Console.WriteLine("=======================================================");
Console.WriteLine("Printing entries as publisher/offer/sku/image/version");
foreach (var offer in publisher.Offers.List())
{
foreach (var sku in offer.Skus.List())
{
foreach (var image in sku.Images.List())
{
Console.WriteLine($"Image - {publisher.Name}/{offer.Name}/{sku.Name}/{image.Version}");
}
}
}
Console.WriteLine("\n\n");
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}