public async Task AddTags(TagModel request)
{
var resourceManagerClient = new ResourcesManagementClient(request.SubscriptionId, _tokenCredential);
var resourceGroupRequest = await resourceManagerClient.ResourceGroups.GetAsync(request.ResourceGroupName);
if (resourceGroupRequest == null)
{
return;
}
var resourceGroup = resourceGroupRequest.Value;
try
{
foreach (var t in request.Tags)
{
resourceGroup.Tags.TryAdd(t.Key, t.Value);
}
await resourceManagerClient.ResourceGroups.CreateOrUpdateAsync(resourceGroup.Name, resourceGroup);
}
catch (Exception ex)
{
// todo: what happens when tagging fails? what's recoverable? what's not?
_log.LogError(ex, ex.Message);
}
}
public override void Execute()
{
#region SETUP
ScenarioContext[] contexts = new ScenarioContext[] { new ScenarioContext(), new ScenarioContext("c9cbd920-c00c-427c-852b-8aaf38badaeb") };
ParallelOptions options = new ParallelOptions
{
MaxDegreeOfParallelism = 1
};
Parallel.ForEach(contexts, options, context =>
{
var createMultipleVms = new CreateMultipleVms(context);
createMultipleVms.Execute();
});
#endregion
var rmClient = new ResourcesManagementClient(Context.SubscriptionId, Context.Credential);
foreach (var sub in rmClient.Subscriptions.List())
{
var compute = new ComputeManagementClient(Context.SubscriptionId, Context.Credential);
// since compute does not provide any filtering service side, filters must be applied client-side
foreach (var vm in compute.VirtualMachines.ListAll().Where(v => v.Name.Contains("MyFilterString")))
{
Console.WriteLine($"Found VM {vm.Name}");
Console.WriteLine("--------Stopping VM--------");
// It is somewhat awkward to have to parse the identity of the VM to get the resoource group to make this call
var resourceGroupName = GetResourceGroup(vm.Id);
compute.VirtualMachines.StartPowerOff(resourceGroupName, vm.Name).WaitForCompletionAsync().ConfigureAwait(false).GetAwaiter().GetResult();
}
}
}
static async Task DeployInfra(string subscriptionId, string resourceGroupPrefix, IConsole console)
{
var client = new ResourcesManagementClient(subscriptionId, _credentials);
var infraGroup = $"{resourceGroupPrefix}-infra";
var vmGroup = $"{resourceGroupPrefix}-vms";
console.Out.Write($"Ensuring resource groups {infraGroup} and {vmGroup} exist\n");
await client.ResourceGroups.CreateOrUpdateAsync(infraGroup, new ResourceGroup("westus2"));
await client.ResourceGroups.CreateOrUpdateAsync(vmGroup, new ResourceGroup("westus2"));
console.Out.Write($"Deploying resources to {infraGroup}\n");
var template = File.ReadAllText(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) !, "azuredeploy.json"));
var parameters = await GetParametersContent(client, infraGroup);
var properties = new DeploymentProperties(DeploymentMode.Incremental)
{
Template = template,
Parameters = parameters,
};
var deploymentOperation = await client.Deployments.StartCreateOrUpdateAsync(infraGroup, _deploymentName, new Deployment(properties));
var deployment = await deploymentOperation.WaitForCompletionAsync();
var outputs = JsonDocument.Parse(JsonSerializer.Serialize(deployment.Value.Properties.Outputs)).RootElement;
var storageAccountName = outputs.GetProperty("storageAccountName").GetProperty("value").GetString();
console.Out.Write($"Deployed resources successfully {storageAccountName}, migrating SQL");
}
public static async Task CreateResourceAsync(
string subscriptionId,
string resourceGroupName,
string location)
{
Console.WriteLine("test");
var credentials = new DefaultAzureCredential(true);
//create
var resourceGroupClient = new ResourcesManagementClient(subscriptionId, credentials).GetResourceGroupsClient();
var resourceGroup = new ResourceGroup(location);
resourceGroup = await resourceGroupClient.CreateOrUpdateAsync("test_rng_name", resourceGroup);
//var createdResourceGroup = res.Value;
Console.WriteLine(resourceGroup.Name);
//update
var tags = new Dictionary <string, string>();
tags.Add("env", "prod");
tags.Add("scenario", "test");
resourceGroup.Tags = tags;
var updatedResourceGroup = await resourceGroupClient.CreateOrUpdateAsync("test_rng_name", resourceGroup);
//get
AsyncPageable <ResourceGroup> response = await resourceGroupClient.ListAsync();
await foreach (ResourceGroupPatchable resourceGroup in response)
{
Console.WriteLine(resourceGroup.Name);
}
}
private static async Task <ResourceGroup> SelectResourceGroupAsync(ResourcesManagementClient rmClient)
{
Console.WriteLine("Available groups:");
var storageAccounts = new ConcurrentBag <ResourceGroup>();
await foreach (var item in rmClient.ResourceGroups.ListAsync().ConfigureAwait(false))
{
Console.WriteLine($"{item.Name}");
storageAccounts.Add(item);
}
Console.WriteLine("Select resource group:");
var name = Console.ReadLine();
while (!storageAccounts.Any(a => a.Name.Equals(name)))
{
Console.WriteLine($"Invalid resource group name: {name}.");
Console.WriteLine("Select resource group:");
name = Console.ReadLine();
}
var resourceGroup = storageAccounts.FirstOrDefault(a => a.Name.Equals(name));
Console.WriteLine($"Selected resource group: {resourceGroup?.Name}.");
return(resourceGroup);
}
static async Task Main(string[] args)
{
var subscriptionId = Environment.GetEnvironmentVariable("AZURE_SUBSCRIPTION_ID");
var resourceClient = new ResourcesManagementClient(subscriptionId, new DefaultAzureCredential());
// Create Resource Group
Console.WriteLine("--------Start create group--------");
var resourceGroups = resourceClient.ResourceGroups;
var location = "westus2";
var resourceGroupName = "QuickStartRG";
var resourceGroup = new ResourceGroup(location);
resourceGroup = await resourceGroups.CreateOrUpdateAsync(resourceGroupName, resourceGroup);
Console.WriteLine("--------Finish create group--------");
// Create a Virtual Machine
await Program.CreateVmAsync(subscriptionId, "QuickStartRG", location, "quickstartvm");
// Delete resource group if necessary
//Console.WriteLine("--------Start delete group--------");
//await (await resourceGroups.StartDeleteAsync(resourceGroupName)).WaitForCompletionAsync();
//Console.WriteLine("--------Finish delete group--------");
//Console.ReadKey();
}
protected async Task initNewRecord()
{
Subscription sub = await ResourcesManagementClient.GetDefaultSubscriptionAsync();
ResourceGroupsOperations = sub.GetResourceGroups();
CosmosDBManagementClient = GetCosmosDBManagementClient();
}
public override void Execute()
{
var createVm = new CreateSingleVmExample(Context);
createVm.Execute();
var rmClient = new ResourcesManagementClient(Context.SubscriptionId, Context.Credential);
var computeClient = new ComputeManagementClient(Context.SubscriptionId, Context.Credential);
var rg = rmClient.ResourceGroups.Get(Context.RgName).Value;
foreach (var entity in rmClient.Resources.ListByResourceGroup(rg.Name, filter: "resourceType eq 'Microsoft.Compute/virtualMachines'"))
{
Console.WriteLine($"{entity.Name}");
var vmUpdate = new VirtualMachineUpdate();
foreach (var pair in entity?.Tags)
{
vmUpdate.Tags.Add(pair.Key, pair.Value);
}
vmUpdate.Tags.Add("name", "value");
// note that it is also possible to use the generic resource Update command, however,
// this requires additional parameters that are difficult to discover, including rp-specific api-version
computeClient.VirtualMachines.StartUpdate(rg.Name, entity.Name, vmUpdate).WaitForCompletionAsync().ConfigureAwait(false).GetAwaiter().GetResult();
}
}
public static void GetDatafactory(IAzure azure, DefaultAzureCredential credential, string subscriptionId, Microsoft.Azure.Management.ResourceManager.Fluent.Authentication.AzureCredentials credentials)
{
ResourcesManagementClient resourceClient = new ResourcesManagementClient(subscriptionId, credential);
Pageable <ResourceGroup> listResourceGroups = resourceClient.ResourceGroups.List();
//var rm = ResourceManager.Configure()
//.WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic)
//.Authenticate(credentials)
//.WithDefaultSubscription();
foreach (var Group in listResourceGroups)
{
Debug.WriteLine("Resource group: " + Group.Name);
var resources = resourceClient.Resources.ListByResourceGroup(Group.Name);
foreach (var rsrce in resources)
{
//Debug.WriteLine(rsrce.Type);
if (String.Compare(rsrce.Type, "Microsoft.DataFactory/factories") == 0)
{
Debug.WriteLine("Resource Name" + rsrce.Name + " Resource Type" + rsrce.Type);
}
}
//var resourcename = resources.ListByResourceGroup(Group.Name);
//var resources1=rm.GenericResources.List();
//foreach (var resource in resourcename)
//{
// Debug.WriteLine(resourcename);
//}
}
}
public static async Task RunSample(TokenCredential credential)
{
var rgName = Utilities.RandomResourceName("rgRSAT", 24);
var deploymentName = Utilities.RandomResourceName("dpRSAT", 24);
var location = "westus";
var subscriptionId = Environment.GetEnvironmentVariable("AZURE_SUBSCRIPTION_ID");
var templateJson = Utilities.GetArmTemplate("ArmTemplate.json");
var resourceClient = new ResourcesManagementClient(subscriptionId, credential);
var resourceGroups = resourceClient.ResourceGroups;
var deployments = resourceClient.Deployments;
try
{
//=============================================================
// Create resource group.
Utilities.Log("Creating a resource group with name: " + rgName);
var resourceGroup = new ResourceGroup(location);
resourceGroup = await resourceGroups.CreateOrUpdateAsync(rgName, resourceGroup);
Utilities.Log("Created a resource group with name: " + rgName);
//=============================================================
// Create a deployment for an Azure App Service via an ARM
// template.
Utilities.Log("Starting a deployment for an Azure App Service: " + deploymentName);
var parameters = new Deployment
(
new DeploymentProperties(DeploymentMode.Incremental)
{
Template = templateJson,
Parameters = "{}"
}
);
var rawResult = await deployments.StartCreateOrUpdateAsync(rgName, deploymentName, parameters);
await rawResult.WaitForCompletionAsync();
Utilities.Log("Completed the deployment: " + deploymentName);
}
finally
{
try
{
Utilities.Log("Deleting Resource Group: " + rgName);
await(await resourceGroups.StartDeleteAsync(rgName)).WaitForCompletionAsync();
Utilities.Log("Deleted Resource Group: " + rgName);
}
catch (Exception ex)
{
Utilities.Log(ex);
}
}
}
public async Task Setup()
{
resourceGroupName = Guid.NewGuid().ToString();
clientId = ExternalVariables.Get(ExternalVariable.AzureSubscriptionClientId);
clientSecret = ExternalVariables.Get(ExternalVariable.AzureSubscriptionPassword);
tenantId = ExternalVariables.Get(ExternalVariable.AzureSubscriptionTenantId);
subscriptionId = ExternalVariables.Get(ExternalVariable.AzureSubscriptionId);
var resourceGroupLocation = Environment.GetEnvironmentVariable("AZURE_NEW_RESOURCE_REGION") ?? "eastus";
authToken = await GetAuthToken(tenantId, clientId, clientSecret);
var resourcesClient = new ResourcesManagementClient(subscriptionId,
new ClientSecretCredential(tenantId, clientId, clientSecret));
resourceGroupClient = resourcesClient.ResourceGroups;
var resourceGroup = new ResourceGroup(resourceGroupLocation);
resourceGroup = await resourceGroupClient.CreateOrUpdateAsync(resourceGroupName, resourceGroup);
webMgmtClient = new WebSiteManagementClient(new TokenCredentials(authToken))
{
SubscriptionId = subscriptionId,
HttpClient = { BaseAddress = new Uri(DefaultVariables.ResourceManagementEndpoint) },
};
var svcPlan = await webMgmtClient.AppServicePlans.BeginCreateOrUpdateAsync(resourceGroup.Name,
resourceGroup.Name, new AppServicePlan(resourceGroup.Location)
{
Kind = "linux",
Reserved = true,
Sku = new SkuDescription
{
Name = "S1",
Tier = "Standard"
}
});
site = await webMgmtClient.WebApps.BeginCreateOrUpdateAsync(resourceGroup.Name, resourceGroup.Name,
new Site(resourceGroup.Location)
{
ServerFarmId = svcPlan.Id,
SiteConfig = new SiteConfig
{
LinuxFxVersion = @"DOCKER|mcr.microsoft.com/azuredocs/aci-helloworld",
AppSettings = new List <NameValuePair>
{
new NameValuePair("DOCKER_REGISTRY_SERVER_URL", "https://index.docker.io"),
new NameValuePair("WEBSITES_ENABLE_APP_SERVICE_STORAGE", "false")
},
AlwaysOn = true
}
});
webappName = site.Name;
await AssertSetupSuccessAsync();
}
static async Task Main(string[] args)
{
string subscriptionId = Environment.GetEnvironmentVariable("AZURE_SUBSCRIPTION_ID");
Console.WriteLine("Subscription ID:" + subscriptionId);
var credential = new DefaultAzureCredential();
var resourcesManagementClient = new ResourcesManagementClient(subscriptionId, credential);
Console.WriteLine("Subscription : " + subscriptionId);
Console.WriteLine("Welcome to AutoCloud.! Manage All your Cloud Infrastructure from Here.");
Console.WriteLine("1. List Your Resources.");
Console.WriteLine("2. Create a New Resource.");
Console.WriteLine("3. Modify an Existing Resource");
Console.WriteLine("4. Delete a Resource");
Console.WriteLine("5. Configure your Cloud Account");
Console.WriteLine("6. Exit");
int action = 0;
action = Convert.ToInt32(Console.ReadLine());
Console.WriteLine(action);
switch (action)
{
case 1:
Console.WriteLine("Listing your resources");
await CreateResourceGroupAsync(resourcesManagementClient);
break;
default:
break;
}
}
static void Main(string[] args)
{
Scenario scenario = null;
try
{
scenario = ScenarioFactory.GetScenario(Scenarios.CreateSingleVmExample);
scenario.Execute();
}
finally
{
var client = new ResourcesManagementClient(scenario.Context.SubscriptionId, scenario.Context.Credential);
foreach (var rgId in Scenario.CleanUp)
{
var name = GetResourceName(rgId);
try
{
var rg = client.ResourceGroups.Get(name).Value;
if (rg != null)
{
Console.WriteLine($"--------Deleting {rg.Name}--------");
_ = client.ResourceGroups.StartDelete(rg.Name).WaitForCompletionAsync().ConfigureAwait(false).GetAwaiter().GetResult();
}
}
catch
{
// ignore errors in get/delete
}
}
}
}
public async Task <Azure.ResourceManager.Resources.Models.ResourceGroup> GetResourceGroup(string subscriptionId,
string resourceGroupName)
{
var resourceManagerClient = new ResourcesManagementClient(subscriptionId, _tokenCredential);
var groupResponse = await resourceManagerClient.ResourceGroups.GetAsync(resourceGroupName);
return(groupResponse.Value);
}
// todo: explore changes required for using resource ID for _any_ resource
public async Task DeleteResource(string subscriptionId, string resourceGroupName)
{
// todo: what-if? --> log deletion, but don't execute
// connect to azure
_log.LogInformation($"Request to delete {resourceGroupName} from subscription {subscriptionId}");
var resourceManagerClient = new ResourcesManagementClient(subscriptionId, _tokenCredential);
await resourceManagerClient.ResourceGroups.StartDeleteAsync(resourceGroupName);
}
/// <summary>
/// Generates the parameters content for azuredeploy.json. Specifies the SQL server password using
/// a key vault reference if possible, otherwise generates a new password.
/// </summary>
/// <returns>The stringified parameters content</returns>
static async Task <string> GetParametersContent(ResourcesManagementClient client, string resourceGroupName)
{
return(JsonSerializer.Serialize(new
{
sqlServerPassword = await GeneratePasswordParameter(client, resourceGroupName, "sqlServerPasswordName"),
vmPassword = await GeneratePasswordParameter(client, resourceGroupName, "vmPasswordName"),
}));
}
protected async Task InitializeClients()
{
SubscriptionId = TestEnvironment.SubscriptionId;
ResourcesManagementClient = GetResourceManagementClient();
Subscription sub = await ResourcesManagementClient.GetDefaultSubscriptionAsync();
ResourceGroupsOperations = sub.GetResourceGroups();
CosmosDBManagementClient = GetCosmosDBManagementClient();
}
/// <summary>
/// Deletes the resource group (and all of its included resources).
/// </summary>
/// <param name="resourcesManagementClient">A credentialed ResourcesManagementClient.</param>
/// <param name="resourceGroupName">The name of the resource group containing the storage account.</param>
/// <returns></returns>
private static async Task DeleteResourceGroupAsync(ResourcesManagementClient resourcesManagementClient, string resourceGroupName)
{
Console.WriteLine($"Deleting resource group {resourceGroupName}...");
ResourceGroupsDeleteOperation deleteOperation = await resourcesManagementClient.ResourceGroups.StartDeleteAsync(resourceGroupName);
await deleteOperation.WaitForCompletionAsync();
Console.WriteLine("Done!");
}
protected void InitializeClients()
{
SubscriptionId = TestEnvironment.SubscriptionId;
Location = TestEnvironment.Location;
NotificationHubsResourceGroupName = TestEnvironment.NotificationHubsResourceGroupName;
NotificationHubsResourceId = TestEnvironment.NotificationHubsResourceId;
NotificationHubsConnectionString = TestEnvironment.NotificationHubsConnectionString;
ResourcesManagementClient = GetResourceManagementClient();
}
public AzureClientInitializer(
TokenCredential credential,
StorageManagementClient storageManagementClient,
ResourcesManagementClient resourcesManagementClient)
{
_credential = credential ?? throw new ArgumentNullException(nameof(credential));
_storageManagementClient = storageManagementClient
?? throw new ArgumentNullException(nameof(storageManagementClient));
_resourcesManagementClient = resourcesManagementClient
?? throw new ArgumentNullException(nameof(resourcesManagementClient));
}
/// <summary>
/// Creates a new resource group with a random name.
/// </summary>
/// <param name="resourcesManagementClient">A credentialed ResourcesManagementClient.</param>
/// <returns></returns>
private static async Task <string> CreateResourceGroupAsync(ResourcesManagementClient resourcesManagementClient)
{
string resourceGroupName = RandomName("rg", 20);
Console.WriteLine($"Creating resource group {resourceGroupName}...");
await resourcesManagementClient.ResourceGroups.CreateOrUpdateAsync(resourceGroupName, new ResourceGroup(ResourceRegion));
Console.WriteLine("Done!");
return(resourceGroupName);
}
public async Task LinkNotificationHub()
{
// Setup resource group for the test. This resource group is deleted by CleanupResourceGroupsAsync after the test ends
Subscription sub = await ResourcesManagementClient.GetDefaultSubscriptionAsync();
var lro = await sub.GetResourceGroups().CreateOrUpdateAsync(
NotificationHubsResourceGroupName,
new ResourceGroupData(Location));
ResourceGroup rg = lro.Value;
CommunicationManagementClient acsClient = GetCommunicationManagementClient();
var resourceName = Recording.GenerateAssetName("sdk-test-link-notif-hub-");
// Create a new resource with a our test parameters
CommunicationServiceCreateOrUpdateOperation result = await acsClient.CommunicationService.StartCreateOrUpdateAsync(
rg.Data.Name,
resourceName,
new CommunicationServiceResource { Location = ResourceLocation, DataLocation = ResourceDataLocation });
await result.WaitForCompletionAsync();
// Check that our resource has been created successfully
Assert.IsTrue(result.HasCompleted);
Assert.IsTrue(result.HasValue);
CommunicationServiceResource resource = result.Value;
// Retrieve
var resourceRetrieved = await acsClient.CommunicationService.GetAsync(rg.Data.Name, resourceName);
Assert.AreEqual(
resourceName,
resourceRetrieved.Value.Name);
Assert.AreEqual(
"Succeeded",
resourceRetrieved.Value.ProvisioningState.ToString());
// Link NotificationHub
var linkNotificationHubResponse = await acsClient.CommunicationService.LinkNotificationHubAsync(
rg.Data.Name,
resourceName,
new LinkNotificationHubParameters(NotificationHubsResourceId, NotificationHubsConnectionString));
Assert.AreEqual(NotificationHubsResourceId, linkNotificationHubResponse.Value.ResourceId);
// Delete
CommunicationServiceDeleteOperation deleteResult = await acsClient.CommunicationService.StartDeleteAsync(rg.Data.Name, resourceName);
await deleteResult.WaitForCompletionAsync();
// Check that our resource has been deleted successfully
Assert.IsTrue(deleteResult.HasCompleted);
Assert.IsTrue(deleteResult.HasValue);
}
protected async Task initNewRecord()
{
ResourcesManagementClient = this.GetResourceManagementClient();
//ResourcesOperations = ResourcesManagementClient.Resources;
//ResourceProvidersOperations = ResourcesManagementClient.Providers;
SubscriptionResource sub = await ResourcesManagementClient.GetDefaultSubscriptionAsync();
ResourceGroupsOperations = sub.GetResourceGroups();
DnsManagementClient = this.GetDnsManagementClient();
RecordSetsOperations = DnsManagementClient.RecordSets;
ZonesOperations = DnsManagementClient.Zones;
}
public async Task CreateVmss(ResourcesManagementClient resourcesClient, string resourceGroupName, string deploymentName)
{
string templateString = File.ReadAllText(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "TestData", "VmssDeploymentTemplate.json"));
DeploymentProperties deploymentProperties = new DeploymentProperties(DeploymentMode.Incremental)
{
Template = templateString
};
Deployment deploymentModel = new Deployment(deploymentProperties);
Operation <DeploymentExtended> deploymentWait = await resourcesClient.Deployments.StartCreateOrUpdateAsync(resourceGroupName, deploymentName, deploymentModel);
await WaitForCompletionAsync(deploymentWait);
}
protected async Task InitializeClients()
{
SubscriptionId = TestEnvironment.SubscriptionId;
ResourcesManagementClient = this.GetResourceManagementClient();
//ResourcesOperations = ResourcesManagementClient.Resources;
//ResourceProvidersOperations = ResourcesManagementClient.Providers;
SubscriptionResource sub = await ResourcesManagementClient.GetDefaultSubscriptionAsync();
ResourceGroupsOperations = sub.GetResourceGroups();
DnsManagementClient = this.GetDnsManagementClient();
RecordSetsOperations = DnsManagementClient.RecordSets;
ZonesOperations = DnsManagementClient.Zones;
}
/// <summary>
/// Main program.
/// </summary>
static async Task <int> Main()
{
string subscriptionId = Environment.GetEnvironmentVariable("AZURE_SUBSCRIPTION_ID");
var credential = new DefaultAzureCredential();
// Azure.ResourceManager.Resources is currently in preview.
var resourcesManagementClient = new ResourcesManagementClient(subscriptionId, credential);
// Azure.ResourceManager.Storage is currently in preview.
var storageManagementClient = new StorageManagementClient(subscriptionId, credential);
int repeat = 0;
const int total = 3;
while (++repeat <= total)
{
Console.WriteLine("Repeat #{0}...", repeat);
try
{
// Create a Resource Group
string resourceGroupName = await CreateResourceGroupAsync(resourcesManagementClient);
// Create a Storage account
string storageName = await CreateStorageAccountAsync(storageManagementClient, resourceGroupName);
// Create a container and upload a blob using a storage connection string
await UploadBlobUsingStorageConnectionStringAsync(storageManagementClient, resourceGroupName, storageName);
// Upload a blob using Azure.Identity.DefaultAzureCredential
await UploadBlobUsingDefaultAzureCredentialAsync(storageManagementClient, resourceGroupName, storageName, credential);
Console.WriteLine("Delete the resources...");
// Delete the resource group
await DeleteResourceGroupAsync(resourcesManagementClient, resourceGroupName);
}
catch (RequestFailedException ex)
{
Console.WriteLine($"Request failed! {ex.Message} {ex.StackTrace}");
return(-1);
}
catch (Exception ex)
{
Console.WriteLine($"Unexpected exception! {ex.Message} {ex.StackTrace}");
return(-1);
}
}
Console.WriteLine("Success!");
return(0);
}
public async Task <string> GetRawTagValue(string subscriptionId, string resourceGroupName, string tagName)
{
var resourceManagerClient = new ResourcesManagementClient(subscriptionId, _tokenCredential);
var resourceGroupRequest = await resourceManagerClient.ResourceGroups.GetAsync(resourceGroupName);
if (resourceGroupRequest == null)
{
return(string.Empty);
}
var resourceGroup = resourceGroupRequest.Value;
resourceGroup.Tags.TryGetValue(tagName, out var tagValue);
return(tagValue ?? string.Empty);
}
protected async Task CleanupResourceGroupsAsync()
{
if (CleanupPolicy != null && Mode != RecordedTestMode.Playback)
{
var resourceGroupsClient = new ResourcesManagementClient(
TestEnvironment.SubscriptionId,
TestEnvironment.Credential,
new ResourcesManagementClientOptions()).ResourceGroups;
foreach (var resourceGroup in CleanupPolicy.ResourceGroupsCreated)
{
await resourceGroupsClient.StartDeleteAsync(resourceGroup);
}
}
}
public async Task <string> ExportResourceGroupTemplateByName(string subscriptionId, string groupName)
{
// POST https://management.azure.com/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/exportTemplate?api-version=2020-06-01
var resourceManagerClient = new ResourcesManagementClient(subscriptionId, _tokenCredential);
var resourceTypesToExport = new Azure.ResourceManager.Resources.Models.ExportTemplateRequest();
resourceTypesToExport.Resources.Add("*");
var exportedTemplate = await resourceManagerClient.ResourceGroups.StartExportTemplateAsync(groupName, resourceTypesToExport);
if (exportedTemplate.HasValue)
{
return((string)exportedTemplate.Value.Template);
}
return(string.Empty);
}
static async Task GetResourceGroups(DefaultAzureCredential credential, string subscriptionId)
{
// Create the resource client that will be used to fetch the resource groups
ResourcesManagementClient resourceClient = new ResourcesManagementClient(subscriptionId, credential);
// Fetch the resource groups and print them out to the screen
Pageable <ResourceGroup> listResourceGroups = resourceClient.ResourceGroups.List();
// Print out results to the console
foreach (var Group in listResourceGroups)
{
Console.WriteLine("Resource group: " + Group.Name);
}
}
