Introduction
Cloud computing allows developers and organizations to use computing resources such as servers, storage, databases, networking, and application platforms without maintaining all of the underlying physical infrastructure themselves.
Microsoft Azure is Microsoft's cloud computing platform. It provides services for hosting applications, storing data, building APIs, analyzing information, implementing artificial intelligence solutions, managing infrastructure, and many other workloads.
For someone beginning with Azure, the number of available services can make the platform seem complicated. A practical way to understand Azure is to start with a simple application and see how a local application can be deployed to the cloud.
In this article, we will create a simple ASP.NET Core application and deploy it to Azure App Service. Along the way, we will understand the basic Azure concepts involved and see how the application can be accessed after deployment.
What Is Microsoft Azure?
Microsoft Azure is a cloud platform that provides managed services and infrastructure for building, deploying, and operating applications.
Instead of purchasing and maintaining a physical server, a developer can use Azure to provision the resources required by an application.
A simplified application architecture looks like this:
User
|
v
Internet
|
v
Azure
|
+---- App Service
|
+---- Database
|
+---- Storage
|
+---- Monitoring
The services selected depend on the requirements of the application.
Why Use Azure?
Azure provides several capabilities that are useful for application development and deployment.
Scalability
Cloud resources can be adjusted according to application requirements. The appropriate scaling approach depends on the Azure service and workload.
For example, an application experiencing increased traffic may require additional compute capacity.
Managed Services
Services such as Azure App Service allow developers to deploy applications without managing the underlying operating system and web server infrastructure in the same way they would with a traditional virtual machine.
Global Infrastructure
Azure provides cloud infrastructure across multiple geographic regions. Organizations can select appropriate regions based on factors such as latency, compliance, data residency, and availability requirements.
Integration
Azure integrates with development and DevOps tools such as Visual Studio, GitHub, Azure DevOps, and other Microsoft services.
Security
Azure provides identity, access management, encryption, monitoring, and other security capabilities. The specific security configuration remains the responsibility of the application and organization.
Common Azure Services
Azure contains services for many different types of workloads.
Requirement | Example Azure Service |
|---|---|
Web application hosting | Azure App Service |
Virtual machines | Azure Virtual Machines |
Serverless code | Azure Functions |
Object storage | Azure Blob Storage |
Relational database | Azure SQL Database |
NoSQL database | Azure Cosmos DB |
Monitoring | Azure Monitor |
Identity | Microsoft Entra ID |
Containers | Azure Container Apps / Azure Kubernetes Service |
AI applications | Azure AI services |
Rather than learning all these services at once, it is easier to start with one practical scenario.
Practical Scenario: Deploy an ASP.NET Core Application
Suppose a developer has created a simple ASP.NET Core web application that works correctly on a local machine.
The application currently runs like this:
Developer Computer
|
v
ASP.NET Core Application
|
v
localhost
The goal is to make the application accessible through the internet.
The target architecture is:
User
|
v
Internet
|
v
Azure App Service
|
v
ASP.NET Core Application
Azure App Service manages much of the infrastructure required to host the web application.
Step 1: Create an ASP.NET Core Application
Create a new ASP.NET Core web application using the .NET CLI:
dotnet new webapp -n AzureDemoApp
cd AzureDemoApp
This creates a simple ASP.NET Core Razor Pages application.
Run the application locally:
dotnet run
The terminal displays a local address similar to:
Now listening on: http://localhost:5000
The exact port can vary depending on the project configuration.
Open the displayed address in a browser.
Step 2: Understand the Local Application
At this stage, the application is running only on the development machine.
The architecture is:
Browser
|
v
Local ASP.NET Core Application
|
v
Developer Machine
Other users cannot access this application over the internet unless the machine is configured to expose it, which is generally not the desired deployment approach for a production application.
The next step is to publish the application and deploy it to Azure.
Step 3: Create an Azure App Service
Sign in to the Azure portal and create an App Service.
During configuration, select the appropriate:
Subscription
Resource group
Application name
Deployment option
Runtime stack
Region
Pricing plan
The application name must be unique for the App Service's public hostname.
A resource group can be used to organize related Azure resources.
For example:
Resource Group
|
+-- AzureDemoApp
|
+-- App Service
+-- App Service Plan
Step 4: Understand the App Service Plan
An App Service runs within an App Service Plan.
The App Service represents the application, while the App Service Plan determines the underlying compute resources and pricing tier used by the application.
Conceptually:
App Service Plan
|
+---- Web App 1
|
+---- Web App 2
|
+---- Web App 3
The exact capabilities available depend on the selected pricing tier.
Step 5: Publish the Application
After creating the Azure App Service, publish the application.
Using the .NET CLI, first publish the project:
dotnet publish -c Release
The compiled application is generated in the project's publish output directory.
The deployment method can vary. Azure App Service supports several deployment approaches, including deployment from development tools and source-control-based workflows.
For a real project, the deployment method should be selected based on the team's development and CI/CD process.
Step 6: Deploy From Visual Studio
If you are using Visual Studio, the application can be published directly to Azure.
The general workflow is:
Visual Studio
|
v
Publish
|
v
Azure
|
v
App Service
In Visual Studio:
Open the ASP.NET Core project.
Right-click the project.
Select Publish.
Select Azure as the target.
Select Azure App Service.
Select the required App Service.
Review the publishing settings.
Start the publishing process.
The exact Visual Studio interface can vary between versions.
Step 7: Access the Deployed Application
After deployment completes, Azure provides a public hostname for the App Service.
The application can then be accessed through a browser.
The final flow is:
Browser
|
| HTTPS
v
Azure App Service
|
v
ASP.NET Core Application
The application that previously ran on localhost is now hosted by Azure.
Example Output
Before deployment, the application can be accessed locally:
http://localhost:5000
After deployment, the same application is available through the App Service hostname provided by Azure.
For example:
https://<your-app-name>.azurewebsites.net
The actual hostname depends on the App Service created for the application.
The browser displays the ASP.NET Core application's home page.
Step 8: Monitor the Application
Deploying an application is only part of running it.
Azure provides monitoring capabilities that can help developers understand application health and diagnose problems.
For example, Azure Monitor and Application Insights can be used to collect application telemetry, depending on the monitoring configuration.
A simplified monitoring flow is:
ASP.NET Core Application
|
v
Application Telemetry
|
v
Azure Monitoring
|
v
Developer
Monitoring can help identify issues such as:
Failed requests.
Exceptions.
Slow responses.
Availability problems.
Dependency failures.
Step 9: Configure Application Settings
Applications commonly need configuration values such as:
Connection strings.
API endpoints.
Feature flags.
Environment-specific settings.
These values should not be hard coded into the application.
For example, instead of writing a production database password directly in source code:
var connectionString = "Server=...;Password=myPassword;";
use configuration:
var connectionString =
builder.Configuration.GetConnectionString("DefaultConnection");
Environment-specific values can then be configured through the appropriate Azure configuration mechanism.
Secrets should be protected using suitable secret-management services and should not be committed to source control.
Step 10: Understand Development and Production Environments
A common cloud application setup separates environments.
For example:
Development
|
v
Testing
|
v
Staging
|
v
Production
Each environment may use different configuration values and resources.
This separation helps reduce the risk of accidentally using production resources during development.
Azure Application Deployment Flow
The complete process can be summarized as:
Create ASP.NET Core Application
|
v
Test Locally
|
v
Create Azure Resources
|
v
Publish Application
|
v
Deploy to App Service
|
v
Test Public Endpoint
|
v
Configure Monitoring
|
v
Maintain Application
Azure Benefits in This Scenario
The example demonstrates several practical benefits of using Azure.
No Physical Web Server Required
The application can be hosted in Azure rather than requiring the development team to purchase and maintain physical web-server infrastructure.
Managed Application Hosting
Azure App Service provides a managed application-hosting environment, reducing the amount of infrastructure administration required compared with managing a server directly.
Deployment Integration
Applications can be deployed through development tools and automated CI/CD workflows.
Monitoring
Azure provides services that can be integrated into an application's monitoring and diagnostics strategy.
Scaling Options
Depending on the App Service plan and application requirements, scaling options are available for handling changing workloads.
Common Azure Mistakes for Beginners
Choosing a Service Without Understanding the Requirement
Not every application needs a virtual machine, Kubernetes cluster, or serverless architecture.
Start with the application's actual requirements.
Ignoring Costs
Cloud resources are not automatically free simply because there is no physical hardware to purchase.
Developers should understand the pricing model of the resources they create and remove unused resources.
Hard-Coding Secrets
Never commit passwords, API keys, access tokens, or other secrets to source control.
Deploying Without Monitoring
A deployed application still needs monitoring, logging, and appropriate alerting.
Using Production Resources for Development
Separate environments help prevent accidental changes to production systems.
Practical Azure Learning Path
Once the basic App Service deployment is understood, the next step can be to introduce additional Azure services.
A practical learning path could be:
ASP.NET Core
|
v
Azure App Service
|
+---- Azure SQL Database
|
+---- Azure Blob Storage
|
+---- Application Insights
|
+---- Microsoft Entra ID
|
+---- CI/CD Pipeline
This approach allows developers to learn Azure incrementally while connecting each service to a practical application requirement.
Conclusion
Microsoft Azure provides a broad collection of cloud services for developing, deploying, and operating applications.
Instead of approaching Azure as a collection of hundreds of independent services, developers can learn the platform more effectively by starting with a practical application scenario.
In this article, we created an ASP.NET Core application, ran it locally, prepared an Azure App Service environment, deployed the application, accessed it through a public endpoint, and discussed monitoring and configuration.
The next step is to expand the application with services such as Azure SQL Database, Blob Storage, Application Insights, identity services, and automated CI/CD.
Azure is most useful when its services are selected according to actual application requirements rather than simply because a particular service is available.
Join the conversation! Your thoughts help the community grow.