public static Azure.IAuthenticated Login(bool loginAzCli)
{
AzureCredentials creds;
if (loginAzCli)
{
Log(0, "Login from Azure CLI");
creds = AzureCliCredentials.Create();
}
else
{
Log(0, "Login from Environment");
//$env:servicePrincipalId, $env:servicePrincipalKey and $env:tenantId
var client = Environment.GetEnvironmentVariable("servicePrincipalId");
var key = Environment.GetEnvironmentVariable("servicePrincipalKey");
var tenant = Environment.GetEnvironmentVariable("tenantId");
creds = new AzureCredentialsFactory().FromServicePrincipal(client,
key,
tenant,
AzureEnvironment.AzureGlobalCloud);
}
var auth = Azure.Configure()
.Authenticate(creds)
;
return(auth);
}
public static AzureCredentials GetCredentialsFromSp()
{
var credentials = new AzureCredentialsFactory().FromServicePrincipal(ClientId, ClientSecret, TenantId,
AzureEnvironment.AzureGlobalCloud);
return(credentials);
}
private AzureCredentials GetAzureCredentials()
{
var factory = new AzureCredentialsFactory();
Debug.Assert(factory != null);
Debug.Assert(_hostEnv != null);
if (_hostEnv.IsDevelopment())
{
return(factory.FromFile("./azureauth.json"));
}
else
{
Debug.Assert(_config != null);
var tenantId = _config["SERVICE_PRINCIPAL_TENANT_ID"];
var servicePrincipalId = _config["SERVICE_PRINCIPAL_ID"];
var servicePrincipalSecret = _config["SERVICE_PRINCIPAL_SECRET"];
return(factory.FromServicePrincipal(servicePrincipalId,
servicePrincipalSecret,
tenantId,
AzureEnvironment.AzureGlobalCloud));
}
}
public static IAzure GetAzureInterface(HttpRequest req, RequestBody requestBody)
{
//Obtain Function Config from Environment Vars
string alwaysEmpty = Environment.GetEnvironmentVariable("NeverExists");
string servicePrincipalClientId = Environment.GetEnvironmentVariable("ServicePrincipal_clientId");
string servicePrincipalClientSecret = Environment.GetEnvironmentVariable("ServicePrincipal_clientSecret");
string servicePrincipalTenantId = Environment.GetEnvironmentVariable("ServicePrincipal_tenantId");
//Generating Credential Factory to generate Azure login credentials
var credentialsFactory = new AzureCredentialsFactory();
AzureCredentials azureCredentials;
if (servicePrincipalClientId != null &&
servicePrincipalClientSecret != null &&
servicePrincipalTenantId != null)
{
//Use servicePrincipal auth for local debugging
azureCredentials = credentialsFactory.FromServicePrincipal(servicePrincipalClientId, servicePrincipalClientSecret, servicePrincipalTenantId, AzureEnvironment.AzureGlobalCloud);
}
else
{
//Authenticate to Azure using the Azure SDK and Azure Functions "system assigned managed Identity"
//Setup of managed Identity needs to be done in the Function settings in the portal or via CLI
azureCredentials = credentialsFactory.FromSystemAssignedManagedServiceIdentity(MSIResourceType.AppService, AzureEnvironment.AzureGlobalCloud);
}
//Authenticate with Azure Credentials to get a working Azure interface (here saved as azure)
return(Azure.Authenticate(azureCredentials).WithSubscription(requestBody.subscriptionId));
}
public override void Configure(IFunctionsHostBuilder builder)
{
var appId = Environment.GetEnvironmentVariable("ApplicationId");
var appSecret = Environment.GetEnvironmentVariable("ApplicationSecret");
var tenantId = Environment.GetEnvironmentVariable("TenantId");
var subscriptionId = Environment.GetEnvironmentVariable("SubscriptionId");
var storageAccountConnectionString = Environment.GetEnvironmentVariable("TestsStorageAccount");
var environment = AzureEnvironment.AzureGlobalCloud;
var credentials = new AzureCredentialsFactory()
.FromServicePrincipal(appId, appSecret, tenantId, environment);
var azure = Azure
.Authenticate(credentials)
.WithSubscription(subscriptionId);
builder.Services.AddHttpClient();
builder.Services.AddSingleton <IFileService, FileService>();
builder.Services.AddSingleton <IContainerInstanceService, ContainerInstanceService>();
builder.Services.AddSingleton <IGatlingService, GatlingService>();
builder.Services.AddSingleton(_ => azure);
builder.Services.AddSingleton(_ =>
{
var storageAccount = CloudStorageAccount.Parse(storageAccountConnectionString);
return(storageAccount.CreateCloudBlobClient());
});
}
public static string CreateAciGroup([ActivityTrigger] Tuple <string, string> args, ILogger log)
{
var creds = new AzureCredentialsFactory().FromServicePrincipal(Environment.GetEnvironmentVariable("client"), Environment.GetEnvironmentVariable("key"), Environment.GetEnvironmentVariable("tenant"), AzureEnvironment.AzureGlobalCloud);
var azure = Azure.Authenticate(creds).WithSubscription(Environment.GetEnvironmentVariable("subscriptionId"));
return(CreateContainerGroup(azure, "azure-poc-rg", "extractor" + args.Item1, Environment.GetEnvironmentVariable("d"), args.Item2));
}
public static void Run([QueueTrigger("cdnpurgequeue", Connection = "AzureWebJobsStorage")] string id, TraceWriter log, ExecutionContext context)
{
var config = GetConfiguration(context);
var creds = new AzureCredentialsFactory().FromServicePrincipal(config[AZURE_APP_CLIENT_ID_KEY], config[AZURE_APP_KEY_KEY], config[AZURE_AD_TENANT_ID_KEY], AzureEnvironment.AzureGlobalCloud);
var azure = Microsoft.Azure.Management.Fluent.Azure.Authenticate(creds).WithSubscription(config[AZURE_SUBSCRIPTION_ID_KEY]);
string contentPath = null;
if (UseStorageOrigin(config))
{
contentPath = $"/{id}/*";
}
else
{
contentPath = $"/{id}";
}
log.Info($"Requesting purge of {contentPath} on CDN endpoint {config[CDN_ENDPOINT_NAME_KEY]}");
azure.CdnProfiles.PurgeEndpointContent(config[CDN_RESOURCE_GROUP_NAME_KEY], config[CDN_PROFILE_NAME_KEY], config[CDN_ENDPOINT_NAME_KEY], new List <string>()
{
contentPath
});
log.Info($"Completed purge of {contentPath} on CDN endpoint {config[CDN_ENDPOINT_NAME_KEY]}");
}
private static IAzure GetAzureContext(PerformContext context)
{
IAzure azure;
try
{
context.WriteLine("Authenticating with Azure using servicePrincipal");
var azureCredentialsFactory = new AzureCredentialsFactory();
var clientId = "29db2293-7e74-4715-9c88-32eece20e270";
var clientSecret = "6O1koUAfwco+8wZHPmrjeOECSQVgAvyZYiuS+6vPbL0=";
var tenantId = "b170db8b-8e00-4ad4-a076-ccc84281725d";
var subscriptionId = "7ebdeab9-8060-4fe5-b6c5-a522c7f206b6";
var azureCredentials = azureCredentialsFactory.FromServicePrincipal(clientId, clientSecret, tenantId,
AzureEnvironment.AzureGlobalCloud);
azure = Azure.Configure().WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic)
.WithRetryPolicy(new RetryPolicy(new TransientErrorIgnoreStrategy(),
new ExponentialBackoffRetryStrategy())).Authenticate(azureCredentials)
.WithSubscription(subscriptionId);
var sub = azure.GetCurrentSubscription();
context.WriteLine($"Authenticated with subscription '{sub.DisplayName}' (ID: {sub.SubscriptionId})");
}
catch (Exception ex)
{
context.SetTextColor(ConsoleTextColor.DarkRed);
context.WriteLine($"\nFailed to authenticate:\n{ex.Message}");
context.ResetTextColor();
throw;
}
return(azure);
}
public static void Main(string[] args)
{
try
{
//=================================================================
// Authenticate
//AzureCredentials credentials = SdkContext.AzureCredentialsFactory.FromFile(Environment.GetEnvironmentVariable("AZURE_AUTH_LOCATION"));
AzureCredentials credentials = new AzureCredentialsFactory().
FromServicePrincipal("62853b31-30ca-4aa9-a76b-1158f9b38988",
"54b50fb1-3e29-476f-8041-44b9e8f0be17",
"d872ecb9-4810-48e3-be11-9fc01a9c7e50",
AzureEnvironment.AzureGlobalCloud);
var azure = Azure
.Configure()
.WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic)
.Authenticate(credentials)
.WithDefaultSubscription();
// Print selected subscription
Utilities.Log("Selected subscription: " + azure.SubscriptionId);
RunSample(azure);
}
catch (Exception ex)
{
Utilities.Log(ex);
}
}
public void Login()
{
string client = "9ab5958d-4850-4f61-9f33-f95692b6d33b";
string secret = ".75_UTS.Hi_BKZHcWntL-3L~kr7txEV-V~";
//string tenant = "greggschneider89gmail.onmicrosoft.com";
string tenant = "6b188bb3-722f-43ec-8c64-5ec81dc576fe";
var creds = new AzureCredentialsFactory().FromServicePrincipal(client, secret, tenant, AzureEnvironment.AzureGlobalCloud);
string subscriptionId = "be6cb7f8-c55a-4882-90eb-3777b108b32f";
Console.WriteLine(creds);
//azure = Azure.Authenticate(creds).WithDefaultSubscription();
//azure = Azure.Authenticate(creds).WithSubscription(subscriptionId);
Console.WriteLine(azure);
//Console.WriteLine("Creating a Windows VM");
//var windowsVM = azure.VirtualMachines.Define("TestServerForAsureSDK")
// .WithRegion(Region.EuropeWest)
// .WithExistingResourceGroup("CTF_platform")
// .WithNewPrimaryNetwork("10.0.0.0/28")
// .WithPrimaryPrivateIPAddressDynamic()
// .WithoutPrimaryPublicIPAddress()
// .WithPopularWindowsImage(KnownWindowsVirtualMachineImage.WindowsServer2012R2Datacenter)
// .WithAdminUsername("rootz")
// .WithAdminPassword("GreggXCyberSparrow!1989SomEr03")
// .WithSize(VirtualMachineSizeTypes.StandardD3V2)
// .Create();
//Console.WriteLine("Created a Windows VM: " + windowsVM.Id);
}
protected void ConfigureAzure()
{
// First try to acquire a token from the MSI endpoint
var creds = default(AzureCredentials);
var credentialFactory = new AzureCredentialsFactory();
// If the ResourceManagementClient does exist, already, just return it.
if (this.AzureMgmt != null)
{
return;
}
else
{
this.logger.LogInformation("ResourcesRepository.ConfigureAzure() instantiating Azure Management Client...");
}
// Try acquiring a token (requires refactoring, learning new Fluent libraries as lots has changed from last time (a while ago))
this.ClientId = Environment.GetEnvironmentVariable(Constants.CLIENT_ID_ENV);
this.ClientSecret = Environment.GetEnvironmentVariable(Constants.CLIENT_SECRET_ENV);
this.TenantId = Environment.GetEnvironmentVariable(Constants.TENANT_ID_ENV);
// The tenant Id is always required (due to eventual RBAC assignments using Graph library which needs the tenant ID)
if (string.IsNullOrWhiteSpace(this.TenantId))
{
throw new Exception($"Missing configuration for {Constants.TENANT_ID_ENV} which is always required!");
}
// If not all details for a service principal are present, try MSI.
this.CredentialsUseSp = !(string.IsNullOrWhiteSpace(this.ClientId) || string.IsNullOrWhiteSpace(this.ClientSecret));
if (this.CredentialsUseSp)
{
creds = credentialFactory.FromServicePrincipal(this.ClientId, this.ClientSecret, this.TenantId, AzureEnvironment.AzureGlobalCloud);
}
else
{
this.logger.LogInformation($"Incomplete details for service principal in environment (clientId, clientSecret or tenantId misssing), trying managed service identity.");
try
{
this.logger.LogInformation("ResourceGroupRepository - acquire token from local MSI.");
creds = credentialFactory.FromMSI(new MSILoginInformation(MSIResourceType.VirtualMachine),
AzureEnvironment.AzureGlobalCloud,
tenantId: this.TenantId)
.WithDefaultSubscription(this.SubscriptionId);
}
catch (MSILoginException msiex)
{
this.logger.LogError($"Failed to acquire token for ResourceProviderRepository with managed service identity: {msiex.Message}!");
throw new Exception("Failed acquiring token!", msiex);
}
}
// Token acquired, successfully. Now configure the API Endpoint
this.AzureMgmt = Azure.Configure()
.WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic)
.Authenticate(creds)
.WithSubscription(this.SubscriptionId);
this.logger.LogInformation("ResourcesRepository.ConfigureAzure() succeeded creating fluent Azure Management Client!");
}
public static object Authenticate(string clientId, string clientSecret, string tenantId, string subscriptionId)
{
var credentials = new AzureCredentialsFactory().FromServicePrincipal(clientId, clientSecret, tenantId, AzureEnvironment.AzureGlobalCloud);
var azure = Microsoft.Azure.Management.Fluent.Azure.Authenticate(credentials).WithSubscription(subscriptionId);
return(azure);
}
static IAzure GetAzure(Cfg cfg)
{
var sp = cfg.App.ServicePrincipal;
var creds = new AzureCredentialsFactory().FromServicePrincipal(sp.ClientId, sp.Secret, sp.TennantId, AzureEnvironment.AzureGlobalCloud);
var azure = Azure.Authenticate(creds).WithSubscription(cfg.App.SubscriptionId);
return(azure);
}
/// <summary>
/// TODO: Clean this up. check and errors.
///
/// Should check the loadbalancer.inner.status to see if update is already in progress.
/// Also should batch the queue items, add and configure multiple up configurations at once if they are in the queue.
/// </summary>
/// <param name="tenantDeployment"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
private async Task <TenantDeployment> ProcessIpDeploymentAsync(TenantDeployment tenantDeployment, CancellationToken cancellationToken)
{
var spId = Environment.GetEnvironmentVariable("SERVICE_PRINCIPAL_ID");
var spSecret = Environment.GetEnvironmentVariable("SERVICE_PRINCIPAL_SECRET");
var spTenantId = Environment.GetEnvironmentVariable("SERVICE_PRINCIPAL_TENANT_ID");
var subscriptionId = Environment.GetEnvironmentVariable("SUBSCRIPTION_ID");
var creds = new AzureCredentialsFactory().FromServicePrincipal(spId, spSecret, spTenantId, AzureEnvironment.AzureGlobalCloud);
var azure = Azure.Authenticate(creds).WithSubscription(subscriptionId);
string loadBalancerName = Environment.GetEnvironmentVariable("LOAD_BALANCER");
string backendPool = Environment.GetEnvironmentVariable("BACKENDPOOL");
string resourcegroup = Environment.GetEnvironmentVariable("RESOURCEGROUP");
string tenantname = $"deployment-{tenantDeployment.Name}";
//TODO check provisioning state of load balancer and delay if currently busy
//var provisioningState = azure.ResourceGroups.GetByName(loadBalancer.ResourceGroupName).ProvisioningState;
try
{
var loadBalancer = await azure.LoadBalancers.GetByResourceGroupAsync(resourcegroup, loadBalancerName, cancellationToken);
ILoadBalancerPublicFrontend publicFrontend = loadBalancer.PublicFrontends.First().Value;
var publicIpAddress = publicFrontend.GetPublicIPAddress();
await loadBalancer.Update()
.DefineTcpProbe(tenantname + "_mc")
.WithPort(tenantDeployment.InternalPort)
.Attach()
.DefineLoadBalancingRule($"{tenantname}_mc")
.WithProtocol(TransportProtocol.Tcp)
.FromExistingPublicIPAddress(publicIpAddress)
.FromFrontendPort(tenantDeployment.InternalPort)
.ToBackend(backendPool)
.ToBackendPort(tenantDeployment.InternalPort)
.WithProbe(tenantname + "_mc")
.Attach()
.DefineTcpProbe(tenantname + "_rcon")
.WithPort(tenantDeployment.RconPort)
.Attach()
.DefineLoadBalancingRule($"{tenantname}_rcon")
.WithProtocol(TransportProtocol.Tcp)
.FromExistingPublicIPAddress(publicIpAddress)
.FromFrontendPort(tenantDeployment.RconPort)
.ToBackend(backendPool)
.ToBackendPort(tenantDeployment.RconPort)
.WithProbe(tenantname + "_rcon")
.Attach()
.ApplyAsync(cancellationToken);
return(new TenantDeployment(CreationStatus.Created, tenantDeployment, publicIpAddress.Fqdn));
}
catch (Exception e)
{
ServiceEventSource.Current.ServiceMessage(this.Context, "error provisioning ip addresses.", e.Message);
return(new TenantDeployment(CreationStatus.InProcess, tenantDeployment));
}
}
public ContainerRunnerLib()
{
#if (DEBUG)
_azure = Azure.Authenticate("./credentials.json").WithDefaultSubscription();
#else
var credentials = new AzureCredentialsFactory().FromSystemAssignedManagedServiceIdentity(MSIResourceType.AppService, AzureEnvironment.AzureGlobalCloud);
_azure = Azure.Authenticate(credentials).WithDefaultSubscription();
#endif
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
ILogger log)
{
int operationDelay = 60000; //1min
var resoureGroupName = System.Environment.GetEnvironmentVariable("RESOURCE_GROUP_NAME", EnvironmentVariableTarget.Process);
var vmScalesetName = System.Environment.GetEnvironmentVariable("VMSS_NAME", EnvironmentVariableTarget.Process);
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;
int ftdCountInt = Convert.ToInt32(COUNT);
log.LogWarning("FtdScaleOut:::: count str {0}, count int {1}", COUNT, ftdCountInt);
log.LogWarning("FtdScaleOut:::: FTD ScaleOut Started (RG : {0}, VMSS: {1}, Count: {2})", resoureGroupName.ToString(), vmScalesetName.ToString(), ftdCountInt);
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 vMachineScaleSet = azure.VirtualMachineScaleSets.GetByResourceGroup(resoureGroupName, vmScalesetName);
log.LogWarning("FtdScaleOut:::: Current VMSS Capacity : {0}", vMachineScaleSet.Capacity.ToString());
var computeManagementClient = new ComputeManagementClient(msiCred)
{
SubscriptionId = azure.SubscriptionId
};
var update = computeManagementClient.VirtualMachineScaleSets.CreateOrUpdateWithHttpMessagesAsync(resoureGroupName, vmScalesetName,
new VirtualMachineScaleSet
{
Location = vMachineScaleSet.RegionName,
Overprovision = false,
Sku = new Sku
{
Capacity = vMachineScaleSet.Capacity + ftdCountInt,
Name = vMachineScaleSet.Sku.Sku.Name,
Tier = vMachineScaleSet.Sku.Sku.Tier
}
});
log.LogInformation("FtdScaleOut:::: FTD Scale Out Started... Please wait");
update.Wait(operationDelay);
log.LogInformation("FtdScaleOut:::: FTD Scale Out Status : {0}", update.Status.ToString());
if ("WaitingForActivation" != update.Status.ToString())
{
log.LogError("FtdScaleOut:::: ScaleOut Operation failed (Status : {0})", update.Status.ToString());
return((ActionResult) new BadRequestObjectResult("ERROR: ScaleOut Operation failed"));
}
vMachineScaleSet = azure.VirtualMachineScaleSets.GetByResourceGroup(resoureGroupName, vmScalesetName);
log.LogWarning("FtdScaleOut:::: Post ScaleOut VMSS Capacity : {0}", vMachineScaleSet.Capacity.ToString());
return((ActionResult) new OkObjectResult("SUCCESS"));
}
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestMessage req, ILogger log)
{
AzureCredentialsFactory factory = new AzureCredentialsFactory();
AzureCredentials msiCred = factory.FromMSI(new MSILoginInformation(MSIResourceType.AppService), AzureEnvironment.AzureGlobalCloud);
var azure = Azure.Configure().WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic).Authenticate(msiCred).WithDefaultSubscription();
var nsg = azure.NetworkSecurityGroups.GetByResourceGroup("TestNSGRG", "RSTestNSG1");
return((ActionResult) new OkObjectResult(string.Format("NSG {0} found with {1} default security rules", nsg.Name, nsg.DefaultSecurityRules.Count)));
}
public static string SayHello3([ActivityTrigger] string name, ILogger log)
{
var creds = new AzureCredentialsFactory().FromServicePrincipal(Environment.GetEnvironmentVariable("client"), Environment.GetEnvironmentVariable("key"), Environment.GetEnvironmentVariable("tenant"), AzureEnvironment.AzureGlobalCloud);
var azure = Azure.Authenticate(creds).WithSubscription(Environment.GetEnvironmentVariable("subscriptionId"));
DeleteContainerGroup(azure, "azure-poc-rg", "extractor" + name);
log.LogInformation($"Saying hello to {name}.");
return($"Hello {name}!");
}
private IAzure GetContext()
{
var credentials = new AzureCredentialsFactory().FromServicePrincipal(
config.ClientId,
config.ClientSecret,
config.TenantId,
AzureEnvironment.AzureGlobalCloud);
return(Azure.Authenticate(credentials).WithDefaultSubscription());
}
public static AzureCredentials GetAzureCredentials(string clientId, string appSecret, string tenantId, string subscriptionId)
{
var credentials = new AzureCredentialsFactory()
.FromServicePrincipal(clientId,
appSecret,
tenantId,
AzureEnvironment.AzureGlobalCloud);
return(credentials.WithDefaultSubscription(subscriptionId));
}
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequestMessage req, TraceWriter log)
{
log.Info("Getting request body params");
dynamic data = await req.Content.ReadAsAsync <object>();
string subscriptionId = data?.subscriptionId;
string resourceGroupName = data?.resourceGroupName;
string vmName = data?.vmName;
if (subscriptionId == null || resourceGroupName == null || vmName == null)
{
return(req.CreateResponse(HttpStatusCode.BadRequest, "Please pass all 3 required parameters in the request body"));
}
log.Info("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.Info("Authenticating with Azure using MSI");
var azure = azureAuth.WithSubscription(subscriptionId);
log.Info("Acquiring VM from Azure");
var vm = azure.VirtualMachines.GetByResourceGroup(resourceGroupName, vmName);
log.Info("Checking VM Id");
log.Info(vm.Id.ToString());
log.Info("Checking VM Powerstate");
log.Info("VM Powerstate : " + vm.PowerState.ToString());
bool vmStarting = false;
if (vm.PowerState.ToString() == "PowerState/running")
{
log.Info("VM is already running");
}
else
{
log.Info("Starting vm " + vmName);
await vm.StartAsync();
vmStarting = true;
}
return(vmStarting == false
? req.CreateResponse(HttpStatusCode.OK, "VM was already started")
: req.CreateResponse(HttpStatusCode.OK, "VM started"));
}
/// <summary>
/// Initialize values for use with sdk
/// </summary>
/// <param name="subscription"></param>
/// <param name="tenant"></param>
/// <param name="client"></param>
/// <param name="key"></param>
public static void InitializeValues(string subscription, string tenant, string client, string key)
{
subscriptionId = subscription;
tenantId = tenant;
clientId = client;
clientKey = key;
var creds = new AzureCredentialsFactory()
.FromServicePrincipal(clientId, clientKey, tenantId, AzureEnvironment.AzureGlobalCloud);
azure = Microsoft.Azure.Management.Fluent.Azure.Authenticate(creds).WithSubscription(subscriptionId);
allVms = azure.VirtualMachines.ListAsync().GetAwaiter().GetResult().ToArray();
}
/// <summary>
/// Gets an <see cref="IAzure"/> by authenticating against Azure AD with a Service Principal
/// </summary>
/// <param name="clientId">The clientId from the AppRegistration in AzureAD</param>
/// <param name="clientSecret">The clientSecret from the AppRegistration in AzureAD</param>
/// <param name="tenantId">The Azure TenantId aka DirectoryId</param>
/// <param name="subscriptionId">(optional) The Subscription to use. Default one is used if empty</param>
/// <returns>An <see cref="IAzure"/> Interface for communication with the Azure Cloud</returns>
public static IAzure GetAzureInterface(string clientId, string clientSecret, string tenantId, string subscriptionId = null)
{
AzureCredentials azureCredentials = new AzureCredentialsFactory()
.FromServicePrincipal(clientId, clientSecret, tenantId, AzureEnvironment.AzureGlobalCloud);
var authenticated = Azure.Authenticate(azureCredentials);
if (subscriptionId == null)
{
return(authenticated.WithDefaultSubscription());
}
return(authenticated.WithSubscription(subscriptionId));
}
public static AzureCredentials GetAzureCredentials()
{
var subscriptionId = "[Subscription_Id]";
var appId = "[App_Id]";
var appSecret = "[App_Secret]";
var tenantId = "[Tenant_Id]";
var environment = AzureEnvironment.AzureGlobalCloud;
var credentials = new AzureCredentialsFactory().FromServicePrincipal(appId, appSecret, tenantId, environment);
return(credentials.WithDefaultSubscription(subscriptionId));
}
public VirtualMachineService(IOptions <AzureSettings> azureSettings)
{
AzureSettings = azureSettings.Value;
var credentials = new AzureCredentialsFactory().FromServicePrincipal(
AzureSettings.ClientId,
AzureSettings.ClientSecret,
AzureSettings.TenantId,
AzureEnvironment.AzureGlobalCloud);
_Azure = Azure.Authenticate(credentials).WithDefaultSubscription();
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
ILogger log)
{
int operationDelay = 90000; //1.5min
var resoureGroupName = System.Environment.GetEnvironmentVariable("RESOURCE_GROUP_NAME", EnvironmentVariableTarget.Process);
var vmScalesetName = System.Environment.GetEnvironmentVariable("VMSS_NAME", EnvironmentVariableTarget.Process);
var subscriptionId = System.Environment.GetEnvironmentVariable("SUBSCRIPTION_ID", EnvironmentVariableTarget.Process);
string instanceid = req.Query["instanceid"];
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
dynamic data = JsonConvert.DeserializeObject(requestBody);
instanceid = instanceid ?? data?.instanceid;
int vmssCapacity = 0;
if (null == instanceid)
{
log.LogError("FtdScaleIn:::: Invalid FTD Instance Id for ScaleIn");
return((ActionResult) new BadRequestObjectResult("ERROR: Invalid FTD Instance Id for ScaleIn"));
}
log.LogWarning("FtdScaleIn:::: FTD Scale-In Started (RG : {0}, VMSS: {1}, FTD InstanceId to Delete: {2} )", resoureGroupName.ToString(), vmScalesetName.ToString(), instanceid);
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 vMachineScaleSet = azure.VirtualMachineScaleSets.GetByResourceGroup(resoureGroupName, vmScalesetName);
vmssCapacity = vMachineScaleSet.Capacity;
log.LogInformation("FtdScaleIn:::: Current VMSS Capacity : {0}", vmssCapacity);
var computeManagementClient = new ComputeManagementClient(msiCred)
{
SubscriptionId = azure.SubscriptionId
};
//var del = computeManagementClient.VirtualMachineScaleSetVMs.DeleteWithHttpMessagesAsync(resoureGroupName, vmScalesetName, instanceid).Result;
var del = computeManagementClient.VirtualMachineScaleSetVMs.DeleteWithHttpMessagesAsync(resoureGroupName, vmScalesetName, instanceid);
del.Wait(operationDelay);
vMachineScaleSet = azure.VirtualMachineScaleSets.GetByResourceGroup(resoureGroupName, vmScalesetName);
log.LogInformation("FtdScaleIn:::: Post ScaleIn VMSS Capacity : {0}", vMachineScaleSet.Capacity.ToString());
if ((vmssCapacity - 1) != vMachineScaleSet.Capacity)
{
log.LogError("FtdScaleIn:::: Failed ScaleIn Operation (vmss capacity: {0})", vMachineScaleSet.Capacity);
return((ActionResult) new BadRequestObjectResult("ERROR: Failed ScaleIn Operation. Don't worry, Azure may be taking longer time to delete, but eventually it may delete"));
}
return((ActionResult) new OkObjectResult("SUCCESS"));
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
var creds = new AzureCredentialsFactory().FromServicePrincipal(AZURE_CLIENT_ID, AZURE_CLIENT_SECRET, AZURE_TENANT_ID, AzureEnvironment.AzureGlobalCloud);
var azure = Azure.Authenticate(creds).WithSubscription(AZURE_SUBSCRIPTION_ID);
List <string> purgedContent = new List <string> {
"/images/*"
};
azure.CdnProfiles.PurgeEndpointContent("RESOURCE_GROUP_NAME", "CDN_PROFILE_NAME", "CDN_ENDPOINT_NAME", purgedContent);
}
public AUTH()
{
ServiceClientCredentials credentials = ApplicationTokenProvider.LoginSilentAsync(domain, new ClientCredential(clientId, clientSecret), ActiveDirectoryServiceSettings.AzureChina).Result;
serviceClientCredentials = credentials;
AzureCredentials creds = new AzureCredentialsFactory().FromServicePrincipal(clientId, clientSecret, domain, AzureEnvironment.AzureChinaCloud);
azureCredentials = creds;
IAzure Iazure = Azure.Authenticate(azureCredentials).WithSubscription(subscriptionId);
azure = Iazure;
}
public async Task <IEnumerable <IVirtualMachine> > GetList()
{
var credentials = new AzureCredentialsFactory()
.FromServicePrincipal(_azureConfiguration.ClientId,
_azureConfiguration.ClientSecret,
_azureConfiguration.TenantId,
AzureEnvironment.AzureGlobalCloud);
var azure = Azure.Authenticate(credentials).WithSubscription(_azureConfiguration.Subscription);
var vms = await azure.VirtualMachines.ListAsync();
return(vms.ToList());
}
public IAzure SignIn()
{
_log.Info("Connecting to Azure subscription");
var creds = new AzureCredentialsFactory().FromServicePrincipal(
_configuration.ClientId,
_configuration.ClientSecret,
_configuration.TenantId,
AzureEnvironment.AzureGlobalCloud);
var azure = Microsoft.Azure.Management.Fluent.Azure.Authenticate(creds)
.WithSubscription(_configuration.SubscriptionId);
_log.Info("Connected to Azure subscription");
return(azure);
}
