Web Deployment Automation - GitHub Actions, Azure Web Apps, and Appsettings

Why Automate the Deployment?

Tim kicks things off by framing the deployment process as something that should always be automated. He describes this not just as a modern best practice, but as a surprisingly simple and approachable task thanks to modern deployment automation tools like GitHub Actions and Azure Web Apps. This eliminates the need for manual deployments, long-winded setups, or configuration errors that often result from manual work.

He makes it clear that automating tasks such as software deployment ensures that every time you push new code, it's automatically built, tested, and deployed in a fully automated workflow.

Building the Application: Blazor Web App

In this portion of the tutorial, Tim demonstrates how to create a basic Blazor application using Visual Studio. He walks through choosing the project type, enabling HTTPS, selecting .NET 8, and configuring render modes. The goal here isn’t to build a complex app but to have a simple project that can be deployed using the same deployment process every time.

These early steps underscore how important it is to develop with a deployment pipeline in mind. By starting with a clean and testable app, development teams can significantly reduce deployment time later.

Using Appsettings for Local Config

Tim proceeds to show how to set up appsettings.json with simulated configuration values. This is essential for configuration management tools and helps teams maintain the separation of settings for testing and production environments.

He explains that by injecting IConfiguration into a Razor component, you can easily display values like connection strings and nested settings—a great practice in cloud native applications where automated processes depend on clean config separation.

Local Secrets for Dev Security

Here, Tim introduces secrets.json, Visual Studio’s feature for automated deployment security. He explains that these secrets override app settings but remain local to the developer's machine, preserving confidentiality and minimizing the chance of leaking credentials into source control.

This part of the tutorial emphasizes devops practices that promote security and consistency across different environments, improving the software delivery cycle without exposing sensitive info.

Version Control and GitHub Integration

One of the most foundational pieces of any CI/CD system is solid version control. Tim uses Git integration in Visual Studio to initialize a repository and push the source code to GitHub. This sets the stage for building a CI/CD pipeline that can detect code changes and start a deployment process automatically.

He mentions how every commit is tracked, which greatly aids operations teams looking to resolve bugs or deploy new features. By using GitHub Actions, the automated deployment process is both traceable and transparent.

Provisioning the Azure Web App

Tim moves over to the Azure portal to demonstrate how to provision a free web app resource. He creates a resource group, assigns it a name, and selects runtime settings like .NET 8 and Linux—common defaults in many cloud native applications.

He notes that even though you're deploying as “code,” Azure actually runs your build artifacts inside containers, effectively abstracting the complexity while providing the tools needed for deployment.

Understanding Free Tier Limitations

For small deployment projects, Azure’s free plan is a great starting point. Tim explains that while it limits CPU usage and disables certain features like deployment slots, it works perfectly for development, demos, or staging.

This explanation reinforces the value of staging environments in software development, allowing teams to test in near-production conditions without incurring cost.

Setting Up CI/CD via Deployment Center

Tim then walks through Azure’s Deployment Center, choosing GitHub as the integration source. This illustrates the heart of the CI/CD model—linking source control to software deployment with continuous integration.

He selects his GitHub repo, sets basic authentication, and generates a YAML file that outlines the automation pipeline. He points out the importance of indentation in YAML, a reminder that even automated deployment setups need attention to detail to avoid errors.

Resolving Authentication Settings

An attempt to deploy reveals that basic authentication is disabled by default. Tim navigates to Azure settings to enable it, showcasing how real-world deployment automation processes often involve dealing with other services and configurations.

Once resolved, he returns to the Deployment Center and successfully initiates the automated workflow, proving that this approach requires very little manual intervention once set up correctly.

CI/CD Workflow Execution

Switching to GitHub, Tim watches the workflow trigger automatically. GitHub Actions builds the app, publishes it, and deploys it to Azure—all based on a simple push to the repo. This continuous deployment approach helps in automatically bug tested code and reduces manual deployments entirely.

The result? A faster release cycle with less downtime and minimal involvement from operations teams after initial configuration.

Using Azure to Manage Secrets

Now in a production setting, Tim shows how to set environment variables in Azure to override appsettings.json without touching the source code.

He explains how to add connection strings and nested values, using double underscores (__) for nested keys. This ensures that developers can maintain code without accessing sensitive data—an ideal DevOps scenario.

This separation of concerns is one of the biggest benefits of deployment automation: developers push clean code, and admins manage configs securely.

Dynamic Configuration Without Code Changes

Tim highlights that changes made in Azure can take effect after a restart—no need to recompile or re-deploy manually. This is particularly useful when different variables need to be used in testing and production environments, reducing the likelihood of configuration errors.

This also allows devops teams to maintain automation even when app settings evolve, making it easy to support multiple deployment environments without rewriting code.

Wrapping Up: Benefits of Deployment Automation

By the end of the video, Tim emphasizes how the entire deployment automation process—from writing code to having it automatically deployed—took about 30 minutes. Once you get the hang of it, it can be done in less than five.

He encourages developers to adopt these automated deployment techniques even for small projects, arguing that they simplify software delivery, reduce bugs, and enable quicker response to new features or issues.

Whether you’re working with Azure, AWS, or Google Cloud, understanding and adopting deployment automation sets the foundation for more scalable and secure software projects.

Conclusion

Tim Corey’s video offers a clear and effective roadmap to setting up a fully automated deployment process. With the help of tools like GitHub Actions and Azure Web Apps, modern devops practices make it easier than ever to automate the deployment of your applications, reduce manual work, and increase reliability across development, testing, and production environments.