Intro and prerequisites.
Microsoft Azure resources can be managed using Azure SDK, which opens a lot of possibilities for third-party applications, thus you can create your own visualization and resource management tools. Let's see how it works by creating a small program. The chosen application name will be ManageAzureResourcesApp and it will be written in .Net Core with C#. But firstly it is necessary to have an Azure subscription(or create a free one) and from the Azure portal to register the application in Active Directory in order to obtain a service principal for application identification. Follow the instructions from the link and after the application registration, you should end up assigning the Contributor role for newly auto-created service principal. Make the role assignment at the subscription level by following the path Azure Portal -> Subscriptions -> select your subscription from the list -> Access control (IAM) -> Grant access to this resource.
add-role-asignment
Application credentials.
Once the application is registered, it's time to collect the information necessary for authentication. All the credential attributes will be placed in one text file, let's name it credentials.txt. It will have the following format required by the Azure SDK:

subscription=<subscription-id>
tenant=<tenant-id>
client=<client-id>
key=<client-key>
managementURI=<management-URI>
baseURL=<base-URL>
authURL=<authentication-URL>
Navigate to the application registration blade by following the path Azure Portal -> Azure Active Directory -> App registrations -> select ManageAzureResourcesApp from the list.
overview-application-registration
Copy the Application ID (client ID) and the Directory ID (tenant ID) to the credentials.txt. Also, do not forget to create an application secret(client-key) and store it as well to the credentials text file. The last bit is the subscription id value that can be taken from your subscription view(path Azure Portal -> Subscriptions -> select your subscription). As a result, you should finish with a file content similar with one listed below:

subscription=c3ea5639-11c9-4b55-98de-cbe91863f1c8
client=e2f97e93-ae6d-422a-86cd-a5eb75f68c6e
key=5-oWB4A3M2bieuU6B.c5v5h-Th-7IA1HaJ
tenant=0c3843a4-94e8-4851-b65d-f3d05fcddb21
managementURI=https://management.core.windows.net/
baseURL=https://management.azure.com/
authURL=https://login.windows.net/
Creating Azure resources.
The application will create several related Azure resources: a resource group, a service plan, a storage account, a web and a function app service. Create a .Net Core console application project and run the following commands to install the necessary packages:

install-package Microsoft.Azure.Management.Fluent
install-package Microsoft.Azure.Management.ResourceManager.Fluent
Main code fragment is listed below:

...
// login
var credentials = 
    SdkContext
    .AzureCredentialsFactory
    .FromFile("credentials.txt");

Console.WriteLine("Connecting..");
var azure =
    Microsoft.Azure.Management.Fluent.Azure
    .Configure()
    .WithLogLevel(HttpLoggingDelegatingHandler.Level.Basic)
    .Authenticate(credentials)
    .WithDefaultSubscription();

var region = Region.EuropeWest;
var groupName = "SDB-resource-group";
var appServicePlanName = "SDB-app-service-plan";
var webAppName = "SDB-web-app";
var funcAppName = "SDB-func-app";
var storageAccName = "sdbstorage92097485130234";

// create Resource Group
Console.WriteLine($"Creating \"{groupName}\"..");
var resourceGroup =
    azure
    .ResourceGroups
    .Define(groupName)
    .WithRegion(region)
    .Create();

// create storage account
Console.WriteLine($"Creating storage \"{storageAccName}\"..");
var storageAccount =
    azure
    .StorageAccounts
    .Define(storageAccName)
    .WithRegion(region)
    .WithExistingResourceGroup(resourceGroup)
    .Create();

// create App Service Plan
Console.WriteLine($"Creating \"{appServicePlanName}\"..");
var appServicePlan = 
    azure
    .AppServices
    .AppServicePlans
    .Define(appServicePlanName)
    .WithRegion(region)
    .WithExistingResourceGroup(resourceGroup)
    .WithPricingTier(PricingTier.FreeF1)
    .WithOperatingSystem(OperatingSystem.Windows)
    .WithCapacity(1)
    .Create();

// create WebApp
Console.WriteLine($"Creating \"{webAppName}\"..");
var webApp = 
    azure
    .AppServices
    .WebApps
    .Define(webAppName)
    .WithExistingWindowsPlan(appServicePlan)
    .WithExistingResourceGroup(resourceGroup)
    .Create();

// create FuncApp
Console.WriteLine($"Creating \"{funcAppName}\"..");
var funcApp =
    azure
    .AppServices
    .FunctionApps
    .Define(funcAppName)
    .WithExistingAppServicePlan(appServicePlan)
    .WithExistingResourceGroup(resourceGroup)
    .WithExistingStorageAccount(storageAccount)
    .Create();
...
The console output should looks like one bellow:
console-create-azure-resources-result
The created resources are visible on the resource group blade:
create-azure-resources-results
Do not forget to delete previously created resources, either manually from the portal or by running the following code:

azure.ResourceGroups.DeleteByName(groupName);
Console application source code can be downloaded from github. The presented example is a trivial one and the same results can be achieved using an ARM template but in general C# code allows more advanced scenarios than templates.