Cloud-Native: Microservices, Kubernetes, Service Mesh, CI/CD

Explore the fundamentals of cloud native applications built on microservices, designed for cloud environments with scalability, resiliency, and rapid innovation via continuous delivery and managed cloud services.

Explore cloud native architecture design principles, including loosely coupled microservices, polyglot programming, API-centric communication, stateless elasticity, resiliency, and container orchestration with Kubernetes.

Discover how cloud native architectures scale horizontally, enable rapid development and deployment with containers and orchestration, and boost resilience, self-healing, fault tolerance, and cost efficiency.

Explore challenges of cloud native architectures, including complexity from microservices, containers, and orchestration tools, skillset gaps, data management, security, and vendor lock-in, while noting benefits like faster innovation and resilience.

Explore the cloud path for legacy applications and how cloud-native modernization boosts agility. Grasp three migration levels—lift and shift, cloud enhanced, cloud native—with examples from AWS and Azure.

Explore cloud native concepts by examining the landscape, trail map, and pillars, and discuss architectures and projects driving cloud native adoption, including what is cloud save.

Explore how the Cloud Native Computing Foundation, part of the Linux Foundation, promotes open source collaboration, supports the community, and hosts Kubernetes and Prometheus to accelerate cloud native adoption.

Explore the Cloud Native Computing Foundation's open, vendor-neutral hub for cloud native projects like Kubernetes and Prometheus; learn project maturity, types, and case studies through a quick CNCF tour.

Explore the cloud native landscape defined by the CNCF, including categories like application development, orchestration, runtime, provisioning, observability, and platforms, with interactive filtering of projects.

Explore the CNCF landscape categories and subcategories, discovering cloud native tools like Kubernetes, Istio, Envoy, gRPC, Kafka, and GitOps projects for CI/CD.

Explore the cloud native landscape and demystify CNCF projects beyond Kubernetes and Docker. Learn core concepts like containers, orchestrators, microservices, and CI/CD through incremental adoption and a safe trial map.

Explore the cloud native trail map from the CNCF, a ten-step guide covering containerization, CI/CD, Kubernetes with Helm, observability with Prometheus/Jaeger, and service mesh options.

Explore cloud native pillars - microservices, containers, orchestration, service mesh, backing services, scalability, DevOps, CI/CD, infrastructure as code, GitOps, and monitoring through hands-on design in Kubernetes-based labs.

Discover the first pillar of cloud native: microservices. Learn what microservices are, their design and implementation for scalable and maintainable applications, and compare monolithic versus microservice architectures with hands-on labs.

Map microservices to 12 factor app principles and cloud native trail map by examining code base, configuration, processes, port binding, and disposability, alongside containers, orchestration, and ci/cd.

Trace the evolution from monolithic to microservices and serverless, guided by cloud native pillars, refactoring toward nano services and event-driven architectures.

Explore what microservices are: small, independent, loosely coupled services with separate code bases that deploy and update independently, communicate via APIs, and own their own data stores.

Explore microservices architecture as building a cloud native single app from small, independently deployable services that communicate via lightweight APIs, owned by autonomous teams with diverse stacks.

Identify a real need for microservice architecture and follow best practices from Microsoft's architectures. Start with modular monolithic design and refactor to microservices only when independent zero-downtime deployment is required.

Identify and avoid microservices antipatterns by preventing distributed monoliths, ensuring bounded context and loose coupling; embrace DevOps, ci/cd, containers, Kubernetes, and asynchronous messaging and event streaming for autonomous services.

Compare monolithic and microservice architectures to determine which design fits your business needs. Discover how microservices enable independent deployment, scalable components, and ci/cd automation for agile, cost-effective development.

Adopt the database-per-service pattern to keep microservices loosely coupled with independent databases and rest apis. Use polyglot persistence to tailor storage for product, shopping cart, and ordering services.

Explore languages and frameworks for microservices, including Java, JavaScript, Python, Go, and C-sharp with Dotnet core, using Spring Boot, Express, Flask, Go micro, and Dotnet core for cloud native microservices.

Explore cloud-native microservices frameworks across Java, Go, Python, JavaScript, and .NET, featuring Spring Boot, Quarkus, Micronaut, Go Micro, Django, Flask, Node.js, Express, and ASP.NET with service discovery and Kubernetes-ready deployment.

Explore cloud managed and serverless microservice frameworks to build scalable, independently deployable units using serverless functions such as AWS Lambda, Azure Functions, Google Cloud Functions, and Vercel H Functions.

Design cloud-native microservice architectures using open source tools like NodeJS or Spring Boot and cloud managed serverless tools such as AWS Lambda or Azure Functions, while analyzing an e-commerce domain.

Explore the e-commerce domain by analyzing and decomposing microservices through use cases, nouns and verbs, and object interaction diagrams to define subdomains and responsibilities.

Identify and decompose microservices for an e-commerce domain, covering synchronous and asynchronous use cases, such as add to basket with discounts and order fulfillment using saga pattern.

Design a cloud-native e-commerce microservices architecture with product catalog, shopping cart, discount, and ordering services, communicating via rest apis and publish/subscribe messaging through an api gateway for scalable operations.

Select polyglot microservice languages and frameworks for a cloud native e-commerce app. Explore open source tools and cloud managed serverless options, with polyglot persistence across databases, gateways, and message brokers.

Explore a dotnet microservices reference architecture for a cloud native ecommerce app, with catalog, basket, discount, and ordering services, gRPC, Rabbitmq, Masstransit, Ocelot, Docker, and elastic stack for centralized logging.

Explore a reference AWS serverless microservices e-commerce app built with Lambda, API gateway, DynamoDB, SQS, and EventBridge, deployed via CDK and CloudFormation for RESTful and event-driven workflows.

Develop a hands-on single product microservice with restful api endpoints (get all products, get by id, post, put, delete) within a cloud-native microservice architecture.

Explore top microservices languages and frameworks via global and Dynatrace reports, including restful product microservices. See why dotnet with C# is used, while any language can be containerized for Kubernetes.

Choose dotnet for cloud native microservices due to cross-platform support, strong performance, and easy containerization with dotnet publish command line interface, Docker, and Kubernetes.

Install prerequisites for cloud native course by installing dotnet sdk, visual studio code, and the c# extension, then set up cloud native folder structure for microservices, containers, and orchestrators.

Develop product microservices with dotnet minimal APIs, exposing fast, lightweight restful endpoints, implementing CRUD operations, dependency injection, and seeding data to support high performance web APIs.

Run the product microservices app with dotnet run, exposing APIs on port 5176, then test CRUD endpoints (get all, get by id, post, put, delete) using a rest client.

Create product microservices with AWS serverless services, implementing RESTful CRUD endpoints using AWS Lambda, API Gateway, and DynamoDB for scalable NoSQL data persistence.

Develop a single product microservice using AWS Lambda, API Gateway, and DynamoDB to expose RESTful CRUD APIs; learn serverless architecture and how to trigger Lambda from API Gateway.

Dive into containers, including definitions, benefits, challenges, runtimes, and registries, and see how Docker and images enable microservice deployments.

Explore how containers embody the 12-factor principles and cloud native trail map, mapping code base, dependencies, config, and build, release, and run to containerization, orchestration, and registries.

Trace the evolution of cloud hosting models from iaas to caas, paas, faas, and serverless, highlighting abstraction, scalability, and efficiency in real-world deployments.

Explore what containers and orchestrators are and why they solve monolithic deployment problems in microservice deployments, enabling independent scaling, updates, and easy rollback with Docker.

Adopt one process per container, use small base images, keep containers stateless, externalize configuration, implement health checks, and apply orchestration, monitoring, and CI/CD for cloud-native apps.

Explore how containers enable lightweight isolation on a shared host, using container images built from layers, runtimes for isolation, Linux namespaces, and networking to run apps with the host kernel.

Understand what a container runtime is—the software that executes and manages containers on host, enabling creation, starting, stopping, and monitoring. Explore runtimes such as Docker, containerd, CRI, CRI-O, and RunC.

A container registry stores container images for cloud-native microservices. Public and private registries like Docker Hub and Azure Container Registry support building, versioning, and secure access in CI/CD.

Compare virtual machines and container runtimes to explain why containers are best fit for running microservices, and package code, dependencies, and runtime into a container image.

Learn how Docker serves as an open platform for developing, shipping, and running applications with portable containers, enabling cloud or on-premises deployment and containerization of microservices.

Learn how to containerize applications with Docker by writing a Dockerfile, building images, and running containers. Discover how registries store and deploy images—public or private—across development and production.

Explore Docker architecture, including the Docker client, daemon, API, images, registries, containers, networks, and volumes, and learn how commands build, run, and manage applications.

Explore container runtimes, registries, and deployment options in the cloud native landscape, comparing open source options like Docker, cri-o, firecracker, and gvisor with cloud-managed serverless services such as AWS Lambda.

Explore container registries in the cloud native landscape, including Docker Hub, Harbour, Kai, JFrog Artifactory, and cloud providers, with RBAC, vulnerability scanning, signing.

Explore container deployment options across the cloud native landscape, including orchestration tools and serverless options such as Kubernetes, Docker Swarm, ECS, AWS Fargate, and Cloud Run.

Explore cloud container services and the abstraction level of container deployments. See examples from AWS, Azure, Google Cloud for app deployments, platform as a service, managed Kubernetes, and serverless options.

Explore the most popular container images for cloud-native microservices, including nginx, redis, postgresql, elasticsearch, kafka, rabbitmq, mongodb, and mysql, and their roles in Kubernetes statefulsets.

Design a cloud-native e-commerce microservices architecture by containerizing product catalog, shopping cart, discount, and ordering services with Docker, enabling synchronous and asynchronous communication, building images via Dockerfiles, and deploying containers.

Explore a reference .NET microservices cloud-native e-commerce app and containerize with Docker, featuring gRPC, RabbitMQ, MongoDB, Redis, PostgreSQL, SQL Server, and Docker Compose.

Build and run the full microservice e-commerce app using docker compose, reviewing docker files and the compose override file to configure databases, messaging, and services.

Containerize product microservices with a .NET app using ASP.NET and Docker to build images, run containers, implement CRUD APIs, push to Docker Hub, and deploy to the cloud.

Install Docker desktop, launch the Docker engine, verify it is ready in your command prompt, and prepare to containerize your microservices on your local computer.

Write a dockerfile for product microservices to build a dotnet 7.0 image, publish the app, and run it in a multi-stage container with a dockerignore optimization.

Create a Docker image for product microservices by running docker build in the product service directory, tagging it as product service. Then verify the new image with Docker image command.

Run a Docker image for product microservices, create and start a container, map ports, and verify the product list at localhost:8080/api/products.

Create a Docker Hub account, log in to the central image registry, tag the product microservices image with your Docker Hub username and version, and push.

Deploy your Docker image to the cloud using Google Cloud Run, AWS App Runner, or Azure Container Instances, with pay-as-you-go pricing and no infrastructure management.

Prepare AWS environment by creating a free-tier account, configuring an IAM user with programmatic access, and using the AWS CLI to push container to ECR and deploy to App Runner.

Enable programmatic access to AWS resources by creating an IAM user, generating access keys, and configuring the AWS CLI to interact with AWS APIs and services.

Push the product microservice Docker image to Amazon Elastic Container Registry (ECR) and deploy it to AWS App Runner, following the step-by-step cloud-native lab workflow.

Deploy product service container to AWS App Runner by selecting the container image from ECR, configuring deployment settings, ports, health checks, and environment variables, then review and create the service.

Delete AWS App Runner resources, clear the Elastic Container Registry repositories and their images, and remove the App Runner access role to complete the cleanup.

Explore container orchestrators and learn why Kubernetes powers microservice deployments, including architecture, components, helm charts, and hands-on labs to design scalable e-commerce apps.

Learn how container orchestrators support the 12-factor app, enabling consistent code bases, backing services, build-release-run separation, stateless processes, scalability, disposability, parity, and admin tasks within the cloud native trail map.

Explore how container orchestrators manage, deploy, and scale containerized applications across cloud-native stages. They integrate with CI/CD, enable observability, and support service mesh, networking, and secret management.

Discover why container orchestrators are essential for deploying microservices, enabling automated provisioning, discovery, scaling, health checks, failure protection, and zero-downtime upgrades across clusters.

Explore how container orchestrators manage deployment, scaling, and monitoring of microservice based containerized applications, using registries and clusters for self-healing and efficient resource allocation.

Container orchestrators like Kubernetes enable cloud native microservices by automating deployment and rollback, scaling services, enabling self-healing, and providing service discovery, load balancing, networking, and security.

Learn best practices for container orchestrators like Kubernetes and Docker: declarative configuration, autoscaling, rolling updates and rollbacks, environment isolation, resource limits, monitoring, storage, ci/cd, and health checks.

Learn how container orchestrators manage deployment, scaling, and operation of containerized apps through scheduling, health checks, service discovery, load balancing, rolling updates, security and access control.

Explore container orchestrator tools across the cloud native landscape, including Kubernetes, Docker Swarm, and Apache Mesos with Marathon, and compare their resource management and deployment features.

Explore cloud managed container orchestrator services such as EKS, GKE, AKS, and OpenShift, and learn how they automate deployment, management, and scaling, with cloud provider integration.

Explore how Datadog container reports show Kubernetes as the defacto standard for cloud-native containers, with rising adoption and managed services driving scalable deployments.

Design a cloud-native e-commerce microservices architecture with Docker for containerization and Kubernetes for orchestration, featuring product catalog, shopping cart, discount, and ordering services.

Design cloud native e-commerce microservices using cloud managed container orchestrators like Amazon EKS and Amazon ECS, enabling deployment, scaling, security, load balancing, and high availability.

Explore Kubernetes as the de facto standard for containers, learning its architecture, components, and deployment patterns for microservice deployments, including Helm charts and scaling strategies.

Explore the CNCF 2022 annual survey findings showing cloud native becoming the norm, with widespread container usage, Kubernetes production deployments, and growing multi-cloud and multi-cluster adoption.

Explore how Kubernetes emerges as the cloud's operating system for modern cloud-native computing, uniting containers with security, microservices, observability, and scalable production workloads.

Explore how Kubernetes sits in the cloud native landscape and trail map, acting as a container orchestrator and using helm charts to define, install, and upgrade Kubernetes applications.

Kubernetes is an open source container orchestrator that automates deployment, management, and scaling of containerized workloads and services through declarative configuration and automation.

Explore Kubernetes use cases across microservice architectures, hybrid and multi-cloud deployments, and CI/CD pipelines, then see how it delivers load balancing, fault tolerance with self-healing, replication, and rolling updates.

Explore Kubernetes architecture, including clusters, the control plane and worker nodes, with etcd, API server, scheduler, controller manager, Kubelet, Kube proxy, and pods running containers.

Explore core kubernetes components: pods, replica sets, deployments, services, config maps, secrets, and volumes, and how deployments declaratively manage replica sets and pods for scalable microservices.

Orchestrate containerized microservices across a cluster by packaging apps, defining desired state with manifests. Kubernetes monitors, scales automatically, and handles rolling updates with health checks.

Explore declarative and imperative Kubernetes management by defining desired state in configuration files and using kubectl apply, alongside direct commands like create, delete, and scale.

Deploy microservices to Kubernetes by setting up Minikube, installing kubectl, and configuring pods, services, deployments, and replica sets; manage exposure with ingress and rolling updates.

Install Minikube and kubectl on your local machine, then verify kubectl version to prepare for the hands-on lab.

Start Minikube on Docker Desktop to bootstrap a Kubernetes cluster, verify with kubectl get pod, and explore the dashboard via hands-on labs on GitHub.

Expose ASP.NET containers to listen on 0.0.0.0 for Kubernetes, updating program.cs and docker configuration, then build, push to Docker Hub, and deploy to Minikube following Kubernetes best practices.

Create a Kubernetes pod by pulling the product microservice image from Docker Hub, writing a YAML pod definition, exposing port 8080, and deploying it to Minikube with kubectl.

Apply a pod YAML to deploy a product microservice from Docker Hub into Minikube. Watch pods, port forward, verify access, and delete resources declaratively.

Avoid creating standalone pods on Kubernetes; use deployments for replica management, rolling updates, scaling, and self-healing to ensure high availability.

Create a Kubernetes deployment YAML to run the product microservice on minikube, enabling replicas, rolling updates, scaling, and self-healing with the Docker Hub image.

Apply a Kubernetes deployment to create three pods from a deployment YAML file, verify pod creation in Minikube, and learn to expose the app with a service for load balancing.

Create a Kubernetes service definition that routes traffic to pods by selector, maps tcp port 880 to 8080, and explains service types like clusterIP, nodePort, load balancer, and external name.

Apply the product service YAML in Kubernetes with kubectl, then expose it as a load balancer and access the product microservice via port forwarding or Minikube service.

Create a single yaml manifest that includes both deployment and service for microservices, enabling access and management with kubectl apply, delete, and ports verification.

Expose product microservice to the internet by configuring an ingress in Kubernetes, using an ingress controller and a cluster IP service, and accessing it via a custom host like product.local.

Create config maps and secrets in Kubernetes to decouple configuration data from pods, and inject log level and API key as environment variables in the product microservice deployment.

Scale container instances in Kubernetes by increasing or decreasing pod replicas through deployments and kubectl, and explore manual and automatic scaling with HPA and Keda.

Deploy and expose microservices on Kubernetes with Minikube, using kubectl to create deployments and services, and access them via minikube service or port forward.

Clean up resources by removing host entries and deleting Kubernetes deployments, services, pods, and ingress with product yaml and kubectl, then stop minikube. Learn how Kubernetes manages containerized microservices.