Deploying .Net Microservices with K8s, AKS and Azure DevOps

Build a standalone shopping MVC web application with its own data, then integrate with the API project, add Docker support, and explore Azure Web App for Container deployment.

Create an ASP.NET Core MVC web project for the shopping client microservice. Clone the GitHub repository, scaffold shopping solution, configure port 5001, and run the standalone microservice before API integration.

Develop a shopping client microservice data model with product context objects and a static in-memory store. Deploy a standalone mvc client to azure and prepare for docker compose and kubernetes.

Create a docker container for the shopping client microservice by adding docker support in Visual Studio, generating a docker file, and building with dotnet publish and an entry point.

Run a Docker container for the shopping client microservice locally, using the Dockerfile and Visual Studio integration to build, run, and debug inside the container.

Learn to run and manage shopping client microservices with Docker, including building images from a Dockerfile, running and debugging in containers, and tagging for development and release pipelines.

This lecture demonstrates using Docker Hub and registries to push and pull images, tag versions, and run containers, and shows creating a shopping app repository for the shopping client image.

Deploy the shopping client microservice to Azure Web App for Container by containerizing with a Dockerfile, pushing images to Docker Hub, and configuring the web app for container deployment.

Start your Azure free trial, navigate the Azure portal, and explore container deployment options such as container instances, container registries, Kubernetes services, and web apps for containers.

Examine Azure web app for containers in the portal, review the Azure App Service plan, deployment from Docker Hub, container settings, and image source with private or public registry options.

Learn how to implement a CI/CD pipeline for a single container on Azure web app for containers by integrating GitHub triggers, Docker builds, image pushes, and automated deployments via webhooks.

Delete unused Azure resources by removing the resource group in the Azure portal to avoid high bills, then prepare for developing the shopping api microservices with docker compose and kubernetes.

Develop the Shopping.API microservice with MongoDB support, enabling CRUD operations for products, connecting to a MongoDB docker container, and preparing Shopping.Client to consume products from the API.

Develop a product controller for the shopping api, remove default controllers, create a product model, and implement a get method that returns a random product for testing.

Copy the data folder into the shopping API project and refactor the product context for the shopping API microservice, replacing mock data with real products and preparing MongoDB integration.

Set launch settings and port numbers for shopping microservices, running api on port 5000 and client on port 5001 via multiple startup projects with local profiles and Docker.

Register an HttpClient factory in the shopping client via dependency injection to call the shopping API with get async and return the product list.

Set up a MongoDB docker database and review the big picture for the Shopping MVC and Shopping.API projects. Then connect the API to a real no-sql MongoDB and begin coding.

Connect to a MongoDB container via an interactive PowerShell terminal using docker exec, then run mongo commands to create a catalog database, products collection, and insert items.

Connect the MongoDB docker container to the shopping API by installing the MongoDB driver, marking the product entity with a bson id, and configuring the connection string in appsettings.json.

Learn to containerize microservices using Docker Compose, creating a multi-container app defined in a single file, building Docker images, and testing locally with Visual Studio container tools for deployment.

Add a docker compose file to orchestrate shopping API, client API, and MongoDB using Visual Studio's container orchestration support, with a shared docker compose yaml and overwrite file.

Add a MongoDB service to the docker-compose file, using a Docker Hub image, and configure ports, volumes, and restart policy in both main and override files for local development.

Learn to run a multi-container app with Docker Compose, configure ports for API and client, debug in Visual Studio, and troubleshoot connectivity between API, client, and MongoDB in dev environment.

Master Docker commands for deploying microservices, including pull, build, and run with port mappings; use Docker compose with override files to manage multi container apps and stop or remove images.

Gain the basics of Kubernetes for deploying microservices, covering architecture, components, and manifest essentials, then learn kubectl commands and YAML configuration files on a local machine.

Discover how Kubernetes automates deploying, managing, and scaling containerized applications. Explore its portable, extensible platform for managing containerized workloads and services, with declarative configuration and a large ecosystem.

Learn how to install and run Kubernetes locally using Docker Desktop, enable Kubernetes in settings, and verify the cluster with kubectl commands.

Create deployments in Kubernetes using kubectl, observe how a deployment spawns a replica set and pods, and learn to edit replicas within the deployment to scale.

explore the declarative kubernetes approach by writing yaml manifests and applying them with kubectl apply, creating and updating deployments, pods, and services via metadata and spec.

Explore declarative Kubernetes testing with yaml files by applying updates via kubectl apply, observing replica sets, pods, and ports, and using logs, exec, and describe for troubleshooting.

Create a Kubernetes service with a dedicated service yaml alongside deployment. Learn yaml structure with metadata, spec, and status, and how labels and endpoints connect deployments to services.

Deploy the Kubernetes dashboard and explore its web-based UI to manage the cluster, applications, and logs, using kubectl apply, proxy, and token-based authentication.

Learn to deploy shopping microservices on Kubernetes by building docker images, creating deployment and service yamls, and configuring configmap and secrets for a local docker Kubernetes cluster.

Create a MongoDB admin secret in Kubernetes by encoding the root username and password in base64, define a secret YAML, apply it with kubectl, and reference it in the deployment.

Use Kubernetes secret values to set the MongoDB username and password in the deployment yaml, retrieving them from the secret, then apply the deployment and verify pods with kubectl.

Create a Kubernetes service definition for a Mongo database in the same YAML file as the deployment, using shared labels to connect deployment and service and expose port 27017.

Build shopping Docker images, tag them, and push to Docker Hub, using Docker Compose to run and verify shopping API and client containers.

Push the shopping client and shopping API images to Docker Hub after logging in, creating two public repositories, and validating uploads to illustrate manual steps before automated pipelines.

Clear docker compose containers and images on your local machine, showing how Kubernetes retrieves images from Docker Hub and prepares upcoming Shopping API and client deployments.

Create a shopping API Kubernetes deployment and service YAML, configuring image from Docker Hub, environment variables, and node port for local testing.

Create a shopping client Kubernetes deployment and service in one YAML file, and define a config map for the shopping API URL to inject environment variables.

Remove and recreate all Kubernetes resources on your Docker cluster using kubectl delete and apply, then prepare for cloud deployment to Azure Kubernetes Services to optimize resource usage.

Deploy shopping microservices to Azure Kubernetes Service (AKS) using Azure Container Registry (ACR), building on locally tested Docker and Kubernetes deployments and exploring cloud migration.

Explore Azure Container Registry (ACR) as a managed private Docker registry to store and manage private container images and artifacts, and deploy them to AKS with automated builds and pipelines.

Azure Kubernetes Service (AKS) simplifies deploying a Kubernetes cluster in Azure and handles health monitoring with a free plan. Push images to ACR and deploy to AKS via Azure CLI.

Push images to ACR and deploy Kubernetes configurations to AKS, updating Kubernetes manifests and testing the cloud deployment.

Prepare multi-container shopping microservices for Azure Kubernetes Service (AKS) by building images with Docker Compose, testing locally, and pushing to Azure container registry for AKS deployment.

Deploy an Azure container registry, enable admin access, push a container image, and deploy it to an Azure Kubernetes Service cluster.

Deploy an Azure Container Registry, tag images with the login server address, push shopping api and shopping client images, and prepare integration with Azure Kubernetes Service.

Deploy an Azure Kubernetes Service cluster to run shopping microservices, attach the shopping ECR for pulling images, and set up kubectl for deployment, scaling, and updates.

Run shopping microservices on Azure Kubernetes Service by updating Kubernetes manifests to use the Azure Container Registry login server and configuring image pull secrets.

Create an image pull secret for Azure Container Registry and ECR with kubectl, then configure deployments to use the secret for authenticating and pulling container images in AKS.

Edit Kubernetes manifest yaml files for deploying to Azure Kubernetes Service, update images to acr, add image pull secrets, and adjust services to cluster ip and load balancer.

Scale shopping applications in AKS by manually scaling pods, scaling deployments via YAML, and configuring autoscaling to automatically adjust frontend and microservice pods.

Scale shopping api and shopping client pods in Azure Kubernetes Service with horizontal pod autoscalers, setting min and max replicas and a 50 percent cpu target via yaml and kubectl.

Decrease cpu usage in shopping api and shopping client deployments to enable zero downtime deployments. Use kubectl rollout deployments to roll out and rollback versions while watching pods on aks.

Explore how Azure DevOps provides tools to plan work, collaborate on code, and build via pipelines, boards, repos, and extensions for Kanban and Scrum methods with continuous integration and delivery.

Automate deploying shopping microservices to AKS using Azure CI/CD pipelines, building docker images, pushing to ACR, and performing zero-downtime rollouts and rollbacks triggered by GitHub changes.

Sign up for Azure DevOps and Azure Pipelines with a Microsoft account, then create an organization and a project to enable CI/CD pipelines.

Create your first Azure Pipelines pipeline to build a GitHub repo, push a Docker image to Azure Container Registry, and deploy to Azure Kubernetes services with generated YAML.

Fixes the pipeline docker task error in azure pipelines by configuring the docker build context and docker file path for the shopping API. Builds and pushes to Azure container registry.

Explore how to choose and configure azure pipelines tasks for deploying .NET microservices to Kubernetes, including kubectl and Kubernetes manifest tasks and required parameters.

Refactor the pipeline for continuous delivery to Azure Kubernetes Service by correcting docker build context, consolidating deployment and service definitions into a shopping api yaml, and triggering Azure Pipelines.

Execute a full continuous delivery pipeline to build and push the shopping API image to the Azure Container Registry, publish artifacts, and deploy to Azure Kubernetes Service with YAML.

Manage pipelines for multi-container microservices with CI/CD flows in Azure Pipelines. Refactor triggers and artifacts, separate pipelines per microservice, and track CI/CD in the code structure.

Create separate pipelines for shopping api and shopping client microservices from existing yaml, trigger related changes, build and push images to Azure container registry, and deploy to Azure Kubernetes service.

Create two pipelines for shopping client microservices in Azure DevOps, triggered by related changes, adapting the shopping API yaml for the client and pushing updates to GitHub.

Rename and trigger shopping pipelines in Azure DevOps to automate microservice deployments with AKS, achieving zero-downtime rollouts for shopping API and shopping client.

Embed Azure pipeline status badges in a GitHub project by adding sample markdown to the readme and configuring pipeline settings to display shopping client and shopping API build badges.