public static async Task <DeploymentExtended> CreateTemplateDeploymentAsync( Microsoft.Rest.TokenCredentials credential, string groupName, string deploymentName, string subscriptionId, object template, object parameters) { var resourceManagementClient = new ResourceManagementClient(credential) { SubscriptionId = subscriptionId }; var deployment = new Microsoft.Azure.Management.ResourceManager.Models.Deployment(); deployment.Properties = new DeploymentProperties { Mode = Microsoft.Azure.Management.ResourceManager.Models.DeploymentMode.Incremental, Template = template, Parameters = parameters }; return(await resourceManagementClient.Deployments.CreateOrUpdateAsync( groupName, deploymentName, deployment )); }
public async Task <IActionResult> List() { var auth = new Microsoft.Rest.TokenCredentials(User.Claims.First(x => x.Type == "access_token").Value); var api = new Auth0SwaggerSampleAPI(new Uri("http://localhost:5000"), auth); return(View(await api.ValuesGetAsync())); }
public AzureBaseManager(IAzureCloudAuthenticationInfo authInfo) { this.AuthInfo = authInfo; switch (this.AuthInfo.AuthenticationMode) { case CloudAuthenticationMode.AccessToken: Microsoft.Rest.TokenCredentials tokenCredentials = new Microsoft.Rest.TokenCredentials(this.AuthInfo.AzureAccessToken); this.ServiceCredentials = tokenCredentials; break; case CloudAuthenticationMode.Certificate: X509Certificate2 cert = new X509Certificate2(this.AuthInfo.CertificateBytes, this.AuthInfo.PfxCertificatePassword, X509KeyStorageFlags.MachineKeySet | X509KeyStorageFlags.PersistKeySet | X509KeyStorageFlags.Exportable); Microsoft.Rest.CertificateCredentials certificateCredentials = new Microsoft.Rest.CertificateCredentials(cert); this.ServiceCredentials = certificateCredentials; break; case CloudAuthenticationMode.PublishingProfile: byte[] managementCertificateBytes = Convert.FromBase64String(this.AuthInfo.ManagementCertificate); X509Certificate2 publishingCert = new X509Certificate2(managementCertificateBytes, string.Empty, X509KeyStorageFlags.MachineKeySet | X509KeyStorageFlags.PersistKeySet | X509KeyStorageFlags.Exportable); Microsoft.Rest.CertificateCredentials publishingCredentials = new CertificateCredentials(publishingCert); this.ServiceCredentials = publishingCredentials; break; } }
private void create_adls_client() { var authenticationContext = new AuthenticationContext($"https://login.windows.net/{tenant_id}"); var credential = new ClientCredential(clientId: client_id, clientSecret: client_key); var result = authenticationContext.AcquireToken(resource: "https://management.core.windows.net/", clientCredential: credential); if (result == null) { throw new InvalidOperationException("Failed to obtain the JWT token"); } string token = result.AccessToken; var _credentials = new TokenCredentials(token); inner_client = new DataLakeStoreFileSystemManagementClient(_credentials); inner_client.SubscriptionId = subscription_id; }
/// <summary> /// Gets the embed url for the report to render /// </summary> /// <returns></returns> protected override string GetEmbedUrl() { if (string.IsNullOrWhiteSpace(this.ReportId)) { return null; } var accessToken = base.GetAccessToken(); if (string.IsNullOrWhiteSpace(accessToken)) { return null; } var credentials = new TokenCredentials(accessToken); using (var client = new PowerBIClient(new Uri(this.BaseUri), credentials)) { var report = client.Reports.GetReports(this.CollectionName, this.WorkspaceId).Value.FirstOrDefault(r => r.Id == this.ReportId); return report?.EmbedUrl; } }
static async Task MainAsync() { // Get the credentials TokenCloudCredentials cloudCreds = GetCredsFromServicePrincipal(); var tokenCreds = new TokenCredentials(cloudCreds.Token); var loggingHandler = new LoggingHandler(new HttpClientHandler()); // Create our own HttpClient so we can do logging var httpClient = new HttpClient(loggingHandler); // Use the creds to create the clients we need _resourceGroupClient = new ResourceManagementClient(cloudCreds, httpClient); _websiteClient = new WebSiteManagementClient(tokenCreds, loggingHandler); _websiteClient.SubscriptionId = cloudCreds.SubscriptionId; await ListResourceGroupsAndSites(); // Note: site names are globally unique, so you may need to change it to avoid conflicts await CreateSite("MyResourceGroup", "MyAppServicePlan", "SampleSiteFromAPI", "West US"); }
public object PostManage(string api_version, [FromBody]JObject data) { HttpRequestAuth reqauth = new HttpRequestAuth(Request); if (!reqauth.IsHeaderVerfied() ) { return new { stat = Constants.ApiStatFailure, code = Constants.ApiErrorCodeInvalidParameter, message = "Invalid Parameters. Wrong headers" }; } if (!reqauth.IsTokenAuthenticated()) { return new { stat = Constants.ApiStatFailure, code = Constants.ApiErrorCodeUnauthorized, message = "No Token" }; } var entities = data["entities"]; VirtualMachineManager vmm; try { var credentials = new TokenCredentials(reqauth.GetTokenCache()); vmm = new VirtualMachineManager(credentials, reqauth.GetSubID()); } catch (CloudException ce) { return new { stat = Constants.ApiStatFailure, code =Constants.ApiErrorCodeUnauthorized, message = ce.Message }; } catch (Exception e) { return new { stat = Constants.ApiStatFailure, code = Constants.ApiErrorCodeUnknownExecutionError, message = e.Message }; } List<Dictionary<string,string>> result_entities = new List<Dictionary<string,string>>(); foreach (var entity in entities) { string action = entity["action"].ToString(); string name = entity["name"].ToString(); string resourcegroup = entity["resourcegroup"].ToString(); string status = string.Empty; string message = string.Empty; try { switch(action){ case "start": vmm.StartVirtualMachine(resourcegroup,name); break; case "stop": vmm.StopVirtualMachine(resourcegroup,name); break; case "restart": vmm.RestartVirtualMachine(resourcegroup,name); break; default: status = Constants.ApiStatFailure; message = "Invalid action param! Need to be either start, stop, or restart"; break; } status = Constants.ApiStatOK; message = "OK"; } catch (Exception e) { status = Constants.ApiStatFailure; message = e.Message; } Dictionary<string, string> result_entity = new Dictionary<string, string>(); result_entity.Add("name", name); result_entity.Add("resourcegroup", resourcegroup); result_entity.Add("action", action); result_entity.Add("status", status); result_entity.Add("message", message); result_entities.Add(result_entity); } return new { stat = Constants.ApiStatOK, result = result_entities }; }
public VirtualMachineManager( TokenCredentials cred, string subid ) { this._client = new ComputeManagementClient(cred) { SubscriptionId = subid }; }
static void Main(string[] args) { string token = GetAuthorizationHeader(); TokenCredentials credential = new TokenCredentials(token); ResourceManagementClient resourcesClient = new ResourceManagementClient(credential) { SubscriptionId = subscriptionId }; StorageManagementClient storageMgmtClient = new StorageManagementClient(credential) { SubscriptionId = subscriptionId }; try { //Register the Storage Resource Provider with the Subscription RegisterStorageResourceProvider(resourcesClient); //Create a new resource group CreateResourceGroup(rgName, resourcesClient); //Create a new account in a specific resource group with the specified account name CreateStorageAccount(rgName, accountName, storageMgmtClient); //Get all the account properties for a given resource group and account name StorageAccount storAcct = storageMgmtClient.StorageAccounts.GetProperties(rgName, accountName); //Get a list of storage accounts within a specific resource group IEnumerable<StorageAccount> storAccts = storageMgmtClient.StorageAccounts.ListByResourceGroup(rgName); //Get all the storage accounts for a given subscription IEnumerable<StorageAccount> storAcctsSub = storageMgmtClient.StorageAccounts.List(); //Get the storage account keys for a given account and resource group IList<StorageAccountKey> acctKeys = storageMgmtClient.StorageAccounts.ListKeys(rgName, accountName).Keys; //Regenerate the account key for a given account in a specific resource group IList<StorageAccountKey> regenAcctKeys = storageMgmtClient.StorageAccounts.RegenerateKey(rgName, accountName, "key1").Keys; //Update the storage account for a given account name and resource group UpdateStorageAccountSku(rgName, accountName, SkuName.StandardLRS, storageMgmtClient); //Check if the account name is available bool? nameAvailable = storageMgmtClient.StorageAccounts.CheckNameAvailability(accountName).NameAvailable; //Delete a storage account with the given account name and a resource group DeleteStorageAccount(rgName, accountName, storageMgmtClient); Console.ReadLine(); } catch(Exception e) { Console.WriteLine(e.Message); Console.ReadLine(); } }
protected IPowerBIClient CreatePowerBIClient(PowerBIToken token) { var jwt = token.Generate(accessKey); var credentials = new TokenCredentials(jwt, "AppToken"); var client = new PowerBIClient(credentials) { BaseUri = new Uri(apiUrl) }; return client; }
private SubscriptionClient GetSubscriptionClient(HttpRequestMessage request) { var creds = new TokenCredentials(request.Headers.GetValues("managementToken").First()); var subscriptionClient = new SubscriptionClient(creds); subscriptionClient.SubscriptionId = Guid.Empty.ToString(); //must be set or validation error. return subscriptionClient; }
/// <summary> /// Create Virtual Network Interface Card, NIC /// </summary> /// <param name="credentials">Credentials to authorize application</param> /// <param name="subscriptionId">SubscriptionID that identifies subscription to create resoruce in</param> /// <param name="resourceGroup">Name of resource group</param> /// <param name="location">Location for resource</param> /// <param name="nicName">Internal name for NIC</param> /// <param name="nicIPConfigName">Internal name for NIC Configuration. Sample only provides one configuration, but could be extended to provide more</param> /// <param name="pip">Public IP Address to be assigned to NIC</param> /// <param name="subnet">Subnet to use for current configuration</param> /// <returns>Awaitable task</returns> private static Task<NetworkInterface> CreateNetworkInterfaceAsync(TokenCredentials credentials, string subscriptionId, string resourceGroup, string location, string nicName, string nicIPConfigName, PublicIPAddress pip, Subnet subnet) { Console.WriteLine("Creating Network Interface"); var networkClient = new NetworkManagementClient(credentials) { SubscriptionId = subscriptionId }; var createNicTask = networkClient.NetworkInterfaces.CreateOrUpdateAsync(resourceGroup, nicName, new NetworkInterface() { Location = location, IpConfigurations = new[] { new NetworkInterfaceIPConfiguration { Name = nicIPConfigName, PrivateIPAllocationMethod = "Dynamic", PublicIPAddress = pip, Subnet = subnet } } }); return createNicTask; }
private IPowerBIClient CreatePowerBIClient(HttpClientHandler handler) { var credentials = new TokenCredentials(AccessKey); return new PowerBIClient(credentials, handler); }
/// <summary> /// Creates (or updates existing) resource group /// </summary> /// <param name="credentials">Credentials to authorize application</param> /// <param name="subscriptionId">SubscriptionID that identifies subscription to create resoruce group in</param> /// <param name="resourceGroup">Name of resource group</param> /// <param name="location">Location for resource group</param> /// <returns>Awaitable task</returns> private static async Task<ResourceGroup> CreateResourceGroupAsync(TokenCredentials credentials, string subscriptionId, string resourceGroup, string location) { Console.WriteLine($"Creating Resource Group {resourceGroup}"); var resourceClient = new ResourceManagementClient(credentials) { SubscriptionId = subscriptionId }; return await resourceClient.ResourceGroups.CreateOrUpdateAsync(resourceGroup, new ResourceGroup { Location = location }); }
/// <summary> /// Creates new Virtual Machine using ARM APIs, one by one, building a complete Virtual Machine from the bottom up including: /// Resource Group, Storage Account, Public IP Address, Virtual Network, Network Interface Card and the Virtual Machine itself. /// /// Sample showcases (among others): /// * Authentication against Azure AD /// * ARM API calls using REST /// * Arm API calls using Azure SDK for .NET /// * How parts of the deployment can be optimized using parallel tasks /// </summary> /// <returns></returns> async static Task ManualArmApiDeployment() { #error Replace the values for storageAccountName and pipDnsName to a globally unique value and then remove or comment this row!!! // Globally unique values used in DNS names const string storageAccountName = "armstorage"; // Globally unique name used for the created storage account, pick a name no one else could have chosen const string pipDnsName = "armdns"; // Globally unique name that will be used as part of the DNS name for your public IP and Virtual Machine // Parameters used in creation of Virtual Machine const string resourceGroup = "manualrg"; // Name of resource group to deploy to const string location = "North Europe"; // Location of deployed resources const string pipAddressName = "pip001"; // Internal name for Public IP Address const string vNetName = "vnet001"; // Internal name for Virtual Network const string vNetAddressPrefix = "10.0.0.0/16"; // Virtual network IP Address Range const string vNetSubnetName = "subnet001"; // Internal name for Subnet const string vNetSubnetPrefix = "10.0.0.0/24"; // Subnet IP Address Range const string nicName = "nic001"; // Internal name for Network Interface Card, NIC const string nicIPConfig = "nicipconfig001"; // Internal name for NIC Configuration const string vmName = "windowsvm001"; // Internal (in the Virtual Network) name for Virtual Machine const string vmSize = "Standard_D2"; // Virtual Machine Size, notice that different location provides availability of different VM Sizes const string vmAdminUsername = "******"; // Username of created user const string vmAdminPassword = "******"; // Password of created user const string vmImagePublisher = "MicrosoftWindowsServer"; // Publisher of used source virtual harddrive image const string vmImageOffer = "WindowsServer"; // Identifies offer from selected Publisher const string vmImageSku = "2012-R2-Datacenter"; // Identifies SKU of selected offer const string vmImageVersion = "latest"; // Version of selected Image SKU const string vmOSDiskName = "osdisk"; // Internal name for VM Operating System Disk // Authenticate against Azure AD using client id and client secret var token = GetAccessToken(TenantId, ClientId, ClientSecret).AccessToken; var credentials = new TokenCredentials(token); // List subscriptions and save first subscription id (might be incorrect if you have several subscriptions) var subscriptionId = (await GetSubscriptionsAsync(token)).FirstOrDefault(); if (subscriptionId == null) throw new Exception("No subscription found"); // Create Resource Group // Await the creation of the storage group since everything else in this deployment // depend on the existense of the resource group. await CreateResourceGroupAsync( credentials, subscriptionId, resourceGroup, location); // Create Storage Account Async var createStorageAccountTask = CreateStorageAccountAsync( credentials, subscriptionId, resourceGroup, location, storageAccountName); // Create Public IP Address Async var createPipTask = CreatePublicIPAddressAsync(credentials, subscriptionId, resourceGroup, location, pipAddressName, pipDnsName); // Create Virtual Network Async var subnets = new[] { new Subnet(vNetSubnetPrefix, vNetSubnetName) }; var createVNetTask = CreateVirtualNetworkAsync( credentials, subscriptionId, resourceGroup, location, vNetName, vNetAddressPrefix, subnets); // Wait for Public IP Address and Virtual Network to be created before continuing // creation of Virtual Network Interface, since it has a dependency to those. Console.WriteLine("Waiting for Public IP Address and Virtual Network to be created"); Task.WaitAll( createPipTask, createVNetTask); Console.WriteLine("Proceeding"); var pip = createPipTask.Result; var vNet = createVNetTask.Result; var subnet = vNet.Subnets.First(); // Create Network Interface var createNicTask = CreateNetworkInterfaceAsync( credentials, subscriptionId, resourceGroup, location, nicName, nicIPConfig, pip, subnet); // Wait for Storage Account and Virtual Network Interface to be created before continuing // creation of Virtual Machine, since it has a dependency to those. Console.WriteLine("Waiting for Storage Account and Network Interface to be created"); Task.WaitAll( createStorageAccountTask, createNicTask); Console.WriteLine("Proceeding"); var storageAccount = createStorageAccountTask.Result; var nic = createNicTask.Result; // Create Virtual Machine // This is last task to complete so await the creation of the Virtual Machine var vm = await CreateVirtualMachineAsync( credentials, subscriptionId, resourceGroup, location, storageAccountName, vmName, vmSize, vmAdminUsername, vmAdminPassword, vmImagePublisher, vmImageOffer, vmImageSku, vmImageVersion, vmOSDiskName, nic.Id); Console.WriteLine("Success!!!"); Console.WriteLine($"VM ProvisioningState: {vm.ProvisioningState}"); }
async static Task TemplatedArmDeployment() { Console.Write("Template URI :"); var templateUri = Console.ReadLine(); Console.Write("Parameters URI :"); var parametersUri = Console.ReadLine(); const string resourceGroup = "templatedrg"; // Name of resource group to deploy to const string location = "North Europe"; // Location of deployed resources // Authenticate against Azure AD using client id and client secret var token = GetAccessToken(TenantId, ClientId, ClientSecret).AccessToken; var credentials = new TokenCredentials(token); // List subscriptions and save first subscription id (might be incorrect if you have several subscriptions) var subscriptionId = (await GetSubscriptionsAsync(token)).FirstOrDefault(); if (subscriptionId == null) throw new Exception("No subscription found"); // Create Resource Group // Await the creation of the storage group since everything else in this deployment // depend on the existence of the resource group. await CreateResourceGroupAsync( credentials, subscriptionId, resourceGroup, location); await CreateTemplatedDeployment(credentials, subscriptionId, resourceGroup, templateUri, parametersUri); }
private static async Task<DeploymentExtended> CreateTemplatedDeployment(TokenCredentials credentials, string subscriptionId, string resourceGroup, string templateUri, string parametersUri) { var resourceClient = new ResourceManagementClient(credentials) { SubscriptionId = subscriptionId }; return await resourceClient.Deployments.BeginCreateOrUpdateAsync(resourceGroup, "mytemplateddeployment", new Deployment( new DeploymentProperties() { Mode = DeploymentMode.Incremental, TemplateLink = new TemplateLink(templateUri), ParametersLink = new ParametersLink(parametersUri) })); }
private static async Task MainAsync() { // Obtain an access token using the "common" AAD resource. This allows the application // to query AAD for information that lies outside the application's tenant (such as for // querying subscription information in your Azure account). AuthenticationContext authContext = new AuthenticationContext(AuthorityUri); AuthenticationResult authResult = authContext.AcquireToken(ResourceUri, ClientId, new Uri(RedirectUri), PromptBehavior.Auto); // The first credential object is used when querying for subscriptions, and is therefore // not associated with a specific subscription. ServiceClientCredentials subscriptionCreds = new TokenCredentials(authResult.AccessToken); string subscriptionId = String.Empty; using (SubscriptionClient subClient = new SubscriptionClient(subscriptionCreds)) { // Ask the user to select a subscription. We'll use the selected subscription's // ID when constructing another credential object used in initializing the management // clients for the remainder of the sample. subscriptionId = await SelectSubscriptionAsync(subClient); } // These credentials are associated with a subscription, and can therefore be used when // creating Resource and Batch management clients for use in manipulating entities within // the subscription (e.g. resource groups and Batch accounts). ServiceClientCredentials creds = new TokenCredentials(authResult.AccessToken); // With the ResourceManagementClient, we create a resource group in which to create the Batch account. using (ResourceManagementClient resourceManagementClient = new ResourceManagementClient(creds)) { resourceManagementClient.SubscriptionId = subscriptionId; // Register with the Batch resource provider; this only needs to be performed once per subscription. resourceManagementClient.Providers.Register(BatchNameSpace); string location = await PromptUserForLocationAsync(resourceManagementClient); await CreateResourceGroupAsync(resourceManagementClient, location); await PerformBatchAccountOperationsAsync(authResult.AccessToken, subscriptionId, location); await DeleteResourceGroupAsync(resourceManagementClient); } }
/// <summary> /// /// </summary> /// <param name="credentials">Credentials to authorize application</param> /// <param name="subscriptionId">SubscriptionID that identifies subscription to create resoruce in</param> /// <param name="resourceGroup">Name of resource group</param> /// <param name="location">Location for resource</param> /// <param name="storageAccountName">Name of Storage Account used to store Virtual HDD on</param> /// <param name="vmName">Name of Virtual Machine</param> /// <param name="vmSize">VM Size as allowed for the current location</param> /// <param name="vmAdminUsername">Admin username</param> /// <param name="vmAdminPassword">Admin password</param> /// <param name="vmImagePublisher">Publisher of VM Image</param> /// <param name="vmImageOffer">Offer from Publisher</param> /// <param name="vmImageSku">SKU of Offer</param> /// <param name="vmImageVersion">Version of SKU</param> /// <param name="vmOSDiskName">Internal name for operating system disk</param> /// <param name="nicId">NIC Identifer, used to attach NIC to VM</param> /// <returns>Awaitable task</returns> private static async Task<VirtualMachine> CreateVirtualMachineAsync(TokenCredentials credentials, string subscriptionId, string resourceGroup, string location, string storageAccountName, string vmName, string vmSize, string vmAdminUsername, string vmAdminPassword, string vmImagePublisher, string vmImageOffer, string vmImageSku, string vmImageVersion, string vmOSDiskName, string nicId) { Console.WriteLine("Creating Virtual Machine (this may take a while)"); var computeClient = new ComputeManagementClient(credentials) { SubscriptionId = subscriptionId }; var vm = await computeClient.VirtualMachines.CreateOrUpdateAsync(resourceGroup, vmName, new VirtualMachine { Location = location, HardwareProfile = new HardwareProfile(vmSize), OsProfile = new OSProfile(vmName, vmAdminUsername, vmAdminPassword), StorageProfile = new StorageProfile( new ImageReference { Publisher = vmImagePublisher, Offer = vmImageOffer, Sku = vmImageSku, Version = vmImageVersion }, new OSDisk { Name = vmOSDiskName, Vhd = new VirtualHardDisk($"http://{storageAccountName}.blob.core.windows.net/vhds/{vmOSDiskName}.vhd"), Caching = "ReadWrite", CreateOption = "FromImage" }), NetworkProfile = new NetworkProfile( new[] { new NetworkInterfaceReference { Id = nicId } }), DiagnosticsProfile = new DiagnosticsProfile( new BootDiagnostics { Enabled = true, StorageUri = $"http://{storageAccountName}.blob.core.windows.net" }) }); return vm; }
/// <summary> /// Create Public IP Address (with DNS name) /// </summary> /// <param name="credentials">Credentials to authorize application</param> /// <param name="subscriptionId">SubscriptionID that identifies subscription to create resoruce in</param> /// <param name="resourceGroup">Name of resource group</param> /// <param name="location">Location for resource</param> /// <param name="pipAddressName">Internal name used to identify Public IP Address within your subscription</param> /// <param name="pipDnsName">Globally unique name. Will be part of Fully Qualified Domain Name, FQDN, used to access resources in Azure</param> /// <returns>Awaitable task</returns> private static Task<PublicIPAddress> CreatePublicIPAddressAsync(TokenCredentials credentials, string subscriptionId, string resourceGroup, string location, string pipAddressName, string pipDnsName) { Console.WriteLine("Creating Public IP"); var networkClient = new NetworkManagementClient(credentials) { SubscriptionId = subscriptionId }; var createPipTask = networkClient.PublicIPAddresses.CreateOrUpdateAsync(resourceGroup, pipAddressName, new PublicIPAddress { Location = location, DnsSettings = new PublicIPAddressDnsSettings { DomainNameLabel = pipDnsName }, PublicIPAllocationMethod = "Dynamic" // This sample doesn't support Static IP Addresses but could be extended to do so }); return createPipTask; }
/// <summary> /// Create Virtual Network /// </summary> /// <param name="credentials">Credentials to authorize application</param> /// <param name="subscriptionId">SubscriptionID that identifies subscription to create resoruce in</param> /// <param name="resourceGroup">Name of resource group</param> /// <param name="location">Location for resource</param> /// <param name="vNetName">Internal name used to identify Virtual Network within your subscription</param> /// <param name="vNetAddressPrefix">IP Address range for Virtual Network</param> /// <param name="subnets">List of Subnets to be provisioned inside the Virtual Network</param> /// <returns>Awaitable task</returns> private static Task<VirtualNetwork> CreateVirtualNetworkAsync(TokenCredentials credentials, string subscriptionId, string resourceGroup, string location, string vNetName, string vNetAddressPrefix, Subnet[] subnets) { Console.WriteLine("Creating Virtual Network"); var networkClient = new NetworkManagementClient(credentials) { SubscriptionId = subscriptionId }; var createVNetTask = networkClient.VirtualNetworks.CreateOrUpdateAsync(resourceGroup, vNetName, new VirtualNetwork { Location = location, AddressSpace = new AddressSpace(new[] { vNetAddressPrefix }), Subnets = subnets }); return createVNetTask; }
/// <summary> /// Creates storage account /// </summary> /// <param name="credentials">Credentials to authorize application</param> /// <param name="subscriptionId">SubscriptionID that identifies subscription to create resoruce in</param> /// <param name="resourceGroup">Name of resource group</param> /// <param name="location">Location for resource</param> /// <param name="storageAccountName">Globally unique name. Will be part of Fully Qualified Domain Name, FQDN, for Storage Account, i.e. storageAccountnName.blob.core.windows.net, etc.</param> /// <param name="accountType">Type of storage account to create</param> /// <returns>Awaitable task</returns> private static async Task<StorageAccount> CreateStorageAccountAsync(TokenCredentials credentials, string subscriptionId, string resourceGroup, string location, string storageAccountName, AccountType accountType = AccountType.StandardLRS) { Console.WriteLine("Creating Storage Account"); var storageClient = new StorageManagementClient(credentials) { SubscriptionId = subscriptionId }; return await storageClient.StorageAccounts.CreateAsync(resourceGroup, storageAccountName, new StorageAccountCreateParameters { Location = location, AccountType = accountType, }); }
private static IPowerBIClient CreatePowerBiClient(PowerBIToken token) { var jwt = token.Generate(ConfigHelper.PowerbiSigningKey); var credentials = new TokenCredentials(jwt, "AppToken"); var client = new PowerBIClient(credentials) { BaseUri = new Uri(ConfigHelper.PowerbiApiUrl) }; return client; }
static async Task MainAsync() { // Set Environment - Choose between Azure public cloud, china cloud and US govt. cloud _environment = AzureEnvironment.PublicEnvironments[EnvironmentName.AzureCloud]; // Get the credentials TokenCloudCredentials cloudCreds = GetCredsFromServicePrincipal(); var tokenCreds = new TokenCredentials(cloudCreds.Token); var loggingHandler = new LoggingHandler(new HttpClientHandler()); // Create our own HttpClient so we can do logging var httpClient = new HttpClient(loggingHandler); // Use the creds to create the clients we need _resourceGroupClient = new ResourceManagementClient(cloudCreds, _environment.GetEndpointAsUri(AzureEnvironment.Endpoint.ResourceManager), httpClient); _websiteClient = new WebSiteManagementClient(_environment.GetEndpointAsUri(AzureEnvironment.Endpoint.ResourceManager), tokenCreds, loggingHandler); _websiteClient.SubscriptionId = cloudCreds.SubscriptionId; await ListResourceGroupsAndSites(); // Note: site names are globally unique, so you may need to change it to avoid conflicts await CreateSite("MyResourceGroup", "MyAppServicePlan", "SampleSiteFromAPI", "West US"); // Upload certificate to resource group await UpdateLoadCertificate("MyResourceGroup", "CertificateName", "West US", "PathToPfxFile", "CertificatePassword"); }
public void Run() { // Try to obtain the authorization token var clientCredential = new ClientCredential(clientId, clientSecret); var context = new AuthenticationContext(string.Format("https://login.windows.net/{0}", tenantId)); var result = context.AcquireTokenAsync("https://management.azure.com/", clientCredential).Result; if (result == null) { throw new InvalidOperationException("Failed to obtain authorization token"); } // Read the token and create the appropriate credentials object string token = result.AccessToken; var credentials = new TokenCredentials(token); // Read the template and parameter file contents JObject templateFileContents = GetJsonFileContents(pathToTemplateFile); JObject parameterFileContents = GetJsonFileContents(pathToParameterFile); // Create the resource manager client var resourceManagementClient = new ResourceManagementClient(credentials); resourceManagementClient.SubscriptionId = subscriptionId; // Create or check that resource group exists EnsureResourceGroupExists(resourceManagementClient, resourceGroupName, resourceGroupLocation); // Start a deployment DeployTemplate(resourceManagementClient, resourceGroupName, deploymentName, templateFileContents, parameterFileContents); }
public static WebSiteManagementClient GetWebSiteManagementClient(IAuthSettings model) { var settings = ActiveDirectoryServiceSettings.Azure; var authContext = new AuthenticationContext(settings.AuthenticationEndpoint + model.Tenant); var token = authContext.AcquireToken(settings.TokenAudience.ToString(), new ClientCredential(model.ClientId.ToString(), model.ClientSecret)); var creds = new TokenCredentials(token.AccessToken); var websiteClient = new WebSiteManagementClient(creds); websiteClient.SubscriptionId = model.SubscriptionId.ToString(); return websiteClient; }
public object GetListAll(string api_version) { HttpRequestAuth reqauth = new HttpRequestAuth(Request); if (!reqauth.IsHeaderVerfied() ) { return new { stat = Constants.ApiStatFailure, code = Constants.ApiErrorCodeInvalidParameter, message = "Invalid Parameters. Wrong headers" }; } if (!reqauth.IsTokenAuthenticated()) { return new { stat = Constants.ApiStatFailure, code = Constants.ApiErrorCodeUnauthorized, message = "No Token" }; } try { var credentials = new TokenCredentials(reqauth.GetTokenCache()); var vmm = new VirtualMachineManager(credentials, reqauth.GetSubID()); List<VirtualMachineObject> vmos = vmm.GetAllVirtualMachines(); return new { stat = Constants.ApiStatOK, result = vmos }; } catch (CloudException ce) { return new { stat = Constants.ApiStatFailure, code =Constants.ApiErrorCodeUnauthorized, message = ce.Message }; } catch (Exception e) { return new { stat = Constants.ApiStatFailure, code = Constants.ApiErrorCodeUnknownExecutionError, message = e.Message }; } }
protected override string GetEmbedUrl() { if(string.IsNullOrWhiteSpace(this.DashboardId) || string.IsNullOrWhiteSpace(this.TileId)) { return null; } var accessToken = base.GetAccessToken(); if (string.IsNullOrWhiteSpace(accessToken)) { return null; } var credentials = new TokenCredentials(accessToken); using (var client = new PowerBIClient(new Uri(this.BaseUri), credentials)) { var tile = client.Dashboards.GetTileByDashboardkeyAndTilekey(this.DashboardId, this.TileId); return tile.EmbedUrl; } }
static IPowerBIClient CreateClient(PowerBIToken token, string accessKey, string apiUrl) { WorkspaceCollectionKeys accessKeys = new WorkspaceCollectionKeys() { Key1 = accessKey }; // Generate a JWT token used when accessing the REST APIs var jwt = token.Generate(accessKeys.Key1); // Create a token credentials with "AppToken" type var credentials = new TokenCredentials(jwt, "AppToken"); // Instantiate your Power BI client passing in the required credentials var client = new PowerBIClient(credentials); // Override the api endpoint base URL. Default value is https://api.powerbi.com client.BaseUri = new Uri(apiUrl); return client; }