Learner's Guide for an Azure C# Web App

Welcome! This guide is for anyone eager to build and deploy a fully functional Azure C# web application.

Warning: Any links are sandboxed, you must CTRL + 'click' in order to open any links.

Motivation

Why learn this?

We've launched a live Azure C# web app! Now anyone - except those on restrictive university Wi-Fi - can visit www.lyricallanguagelearning.com and use our platform. This transforms your project from a solo exercise into a real-world tool that helps others learn languages, though this can just be the framework, a basic skeleton for any app!

• Real impact: Your work becomes a publicly accessible service, not just a code sample.
• Skill building: You'll map out relational database design on a manageable scale before tackling larger corporate systems.
• Industry insight: Gain intuition for Agile workflows, microservices architecture, and continuous deployment - core practices in modern development.
• End-to-end understanding: Purchase and configure a custom domain, link resources, manage DNS, and secure your site with SSL.
• Career value: These skills are directly transferable to professional roles and could even enable you to monetize your apps.

In short, this journey equips you with the practical know-how to take ideas from local development all the way to a live, scalable, and secure web application on Azure. Happy coding!

Prerequisites

Before diving in, you should be comfortable with:

• C# and .NET Fundamentals: Understand basic syntax, object-oriented concepts, and the .NET CLI.
  • Learn: C# Tutorial, Get started with .NET CLI
• Web Development Basics: Familiarity with HTTP, RESTful APIs, and ASP.NET Core MVC or Minimal APIs.
  • Learn: ASP.NET Core Tutorial
• Relational Databases and SQL: Know how to design tables, write CRUD queries, and use migrations.
  • Personal Favourite: W3Schools SQL
  • Learn (others): SQL Basics, Entity Framework Core
• Version Control with Git: Basic commands for committing, branching, and merging in GitHub.
  • Learn: Git Basics
• Azure Fundamentals: Core Azure concepts like Resource Groups, App Service, and Azure SQL.
  • Learn: Azure Fundamentals
• DNS and Domain Management: Understanding of CNAME, TXT records, and TTL values.
  • Learn: DNS Concepts

Who This Guide Is For

• Aspiring Full-Stack Developers looking to add cloud deployment to your skill set.
• C#/.NET Developers who want to transition projects from local to Azure.
• Students & Learners seeking a hands-on, end-to-end deployment experience.
• Professionals aiming to understand real-world setup of domains, SSL, and CI/CD pipelines.

With these foundations in place, you'll be ready to follow along and build your first Azure-hosted C# web application!

Mastery Roadmap

Follow this high-level process to master Azure C# web app deployment:

1. Set Up Your Environment

   • Install .NET 6+ SDK, your IDE (VS 2022/VS Code) and Azure CLI.
   • Resource: .NET CLI Quickstart

2. Build a Local C# Web App

   • Project scaffolding: Scaffold an API or MVC app (dotnet new), connect to your DB via appsettings.json, and debug locally with dotnet watch run.
   • Run and debug locally; verify endpoints with Logstream app.MapGet('Message') if deploying or my strongly advised method of using connection strings in appsettings.json to link to the database and deploy locally using dotnet build, dotnet watch run. Vital!!! - Go to SQL-DB/Settings/Connection_Strings and it will be easy to know the format you need.
   • Resource: ASP.NET Core Tutorials

3. Use Entity Framework Core

   • Add EF Core, define your DbContext and entities, then scaffold/update via migrations.
     • Migrations: Use dotnet ef migrations add InitialCreate and dotnet ef database update to set up your schema.
     • Query data: Learn to query data using EF Core as this makes the process automatable and procedural - something I wish I had used more!
   • Resource: EF Core Documentation

4. Version Control & Workflow

   • Use Git with feature branches, pull requests, and a Kanbn board to track work.
     • Task management: Implement a Kanbn board (GitHub Projects or Trello) to track user stories, bugs, and tasks ~ this requires a simple installation of the extension.
   • Resource: Git Basics, Kanbn vs Scrum

5. Deploy to Azure

   • Provision Azure SQL (portal-or-REST), set firewall rules for your dev IP and App Service, and store your connection string in App Settings.
     • Verify your app's public endpoint and view logs in the portal.
   • Resource: Azure App Service Quickstart,Everything Azure

6. Configure Azure SQL

   • Create an Azure SQL Database through the portal or REST-API.
   • CD: Azure's continuous deployment can be enabled with a single click once your GitHub repository is linked - automating every push - though you'll still need to implement robust testing not covered in this guide.
   • Set firewall rules to allow your IP('s) and the App Service inbound traffic (later it is easy enough to add you current IP under Networking in your app).
   • Connection strings: Store securely in App Service settings (don't need to hardcode in code unless in development).
   • Resource: Create Azure SQL via REST API
   • Optional Manual Creation Resource: CI/CD for Azure App Service

7. Enable Logging & Diagnostics

   • Configure application logging in Program.cs with builder.Logging.AddAzureWebAppDiagnostics().
   • Set up Stream logs in the portal's Log Stream - this step is optional for basic setups / simple development but may be invaluable as your project grows.
   • Resource: App Service Diagnostic Logs, Enable diagnostic logging for apps in Azure App Service ~ the latter was useful in understanding everything but not neccessarily making it work.

8. DNS & Custom Domain

   • Upgrade to B1 under App Service Plan., point your custom domain via CNAME/TXT and bind an App Service Managed Certificate.
   • Purchase a domain and configure DNS records (CNAME for www, TXT for verification). We used namecheap, but others like GoDaddy, also under custom domain in your Azure App for $11.99 at time of writing.
   • Add custom domain in App Service Settings/Custom_Domains or Overview and validate with the TXT record.
   • SSL/TLS binding: Use SNI SSL with a free App Service Managed Certificate.
   • Resource: DNS Overview, WhatsMyDNS ~ Very, very useful for checking if the DNS is working / status!!!

9. Add Advanced Features
   Some things for any coders willing to take this further / look into more detailed aspects. These are part of our current/future plans.

• Integrate Azure Cognitive Services (Translator, Speech) for multilingual functionality.

• Test with mock data: use the provided lyrics sample to validate translation and search features.

• Implement a simple JS chat interface

• Resource: Azure Translator

• Inspiration: HTML/CSS Chat Box

• Scale & Optimize

  • Performance tuning: use Application Insights to monitor telemetry and identify bottlenecks.
  • Microservices: further explore Azure Functions or containerized services if needed.
  • Cost management: set budgets and alerts in Azure Cost Management.
  • Resource: Azure Architecture Center

Some further learning resources

Mock Lyrics: Under a Green Willow, When the Sky Falls

Evaluation

How useful is the skill, compared with the effort of learning it? What similar alternatives are there?

Overall, this project has been a hugely informative experience packed with new knowledge and practical skills. Working in .NET and Azure sharpened my understanding of end-to-end full-stack development, but along the way I learned plenty about process too.

• Outsource front-end? Could have saved hours by looping in a React or Angular specialist, or even using a low-code front-end tool. Shifting UI work off my plate would let me focus on API and DB logic without constant context-switching.
• Possibly could have used something other than .NET as editing the code was, to start with, very confusing and intangled with other aspects though once you get used to it you come to like the clean separation of files for different aspects of different pages.
• Local vs cloud testing: Five-minute Azure redeployments for each logging tweak cost me nearly an entire day! Running local emulators (Azurite, SQL Server Docker) and toggling connection strings dynamically would avoid long waits and speed up debugging. I think that lost me a whole day and a lot of frustation.
• We weren't sure if we would have time to buy a domain but ultimalely - plan your tier: Free tiers are tempting, but starting on a B1 App Service plan would enable managed identities, Entra Authentication, a smoother security setup and no trouble with connection strings though now I've come to think they're quite clean but that's only when you know the correct format etc. SQL-DB/Settings/Connection_Strings → easy!!!!
  • Security best practices: While SQL auth worked, using managed identities and Azure Key Vault for secrets is the industry standard. Investing time in secure secret storage upfront reduces later compliance headaches.
• Automate DB seeds: Designing a clean lyrics/translation schema sharpened my relational intuition, but manually putting the data in was tedious. Next time, I'd definitely use the EF Core migrations to automate table creation and initial data loads.

All said, the effort was worth it! These skills are broadly relevant and have given a solid base of understanding for the creative part of my future system design career aspirations.