Top 8 Recommended Istio Service Mesh Self-Study Materials! [September 2023]

Istio is one of the most talked-about frameworks in recent years! If you've worked with Kubernetes before, then you'll want to learn Istio! With this hands-on, practical course, you'll be able to gain experience in running your own Istio Service Meshes.

The course has now been updated to Istio 1.15, which now supports Apple M1 (and ARM processors in general).

This course is designed to be clear and understandable - and fun! But we also go into detail - you'll be learning how to use Istio in real production scenarios - and you'll be looking at the inner workings of Istio.

You can run this course on your own computer, using Minikube (8Gb of Host Ram required) - you don't need a cloud provider, although you can also run the course there - anywhere that you can run Kubernetes!

After a brief talk about what Istio is, we go straight into a hands-on demo, where you'll experience how Istio can solve difficult problems on live projects.

Then you'll find out the details of:

• Traffic Management

• Telemetry

• Visualisation (with Kiali)

• Distributed Tracing (with Jaeger)

• Using Grafana to monitor network traffic

• How to deploy canary releases

• How to do "Dark Releases"

• Istio VirtualServices and DestinationRules

• Load Balancing and Session Affinity

• Istio Gateways

• Resilience testing with Fault Injection

• Circuit Breaking/Outlier Detection

• Securing cluster traffic with Mutual TLS (mTLS)

The "learning curve" for Istio is steep - which is why I've designed this course to be as clear and understandable as possible, and I hope with the hands-on demos, you'll also have fun along the way. But most of all, Istio is an extremely powerful tool, and it's a great addition to your CV!

1. Introduction
2. Introduction
3. Course Downloads
4. Getting Started
5. What is Istio?
6. Hands on Demo
7. What to expect in this section
8. Installing Minikube
9. Getting Istio Running
10. Enabling Sidecar Injection
11. Visualizing the System with Kiali
12. Finding Performance Problems
13. Introducing Envoy
14. Introducing Envoy - The Data Plane
15. The next lecture is optional!
16. Going Deeper into Envoy (Optional Video)
17. Telemetry
18. Starting the Demo System
19. Kiali Deeper Dive
20. Kiali Dynamic Traffic Routing
21. Distributed Tracing Overview
22. Using Jaeger UI
23. Why you need to "Propagate Headers"
24. What happens if you don't propagate headers?
25. Metrics with Grafana
26. Traffic Management
27. Introducing Canaries
28. Canaries with Replicas
29. Version Grouping
30. Elegant Canaries and Staged Releases
31. What is an Istio VirtualService?
32. VirtualService Configuration in yaml
33. What is an Istio DestinationRule?
34. Load Balancing
35. Session Affinity ("Stickiness")
36. What is Consistent Hashing useful for?
37. Gateways
38. Why do I need an Ingress Gateway?
39. Edge Proxies and Gateways
40. Prefix based routing
41. Subdomain Routing
42. Dark Releases
43. Using a browser extension to modify headers
44. If you have problems in the next section
45. Header Based Routing
46. Dark Releases for all Microservices
47. Fault Injection
48. Fault Injection
49. Circuit Breaking
50. Cascading Failures
51. Configuring Outlier Detection
52. Testing Circuit Breakers
53. Mutual TLS
54. Why is encryption needed inside a cluster?
55. How Istio can upgrade traffic to TLS
56. Enabling mTLS - it's Automatic
57. STRICT vs PERMISSIVE mTLS
58. STRICT mTLS Works in Both Directions
59. Customizing and Installing Istio with Istioctl (updated for 2021, Istio 1.8+)
60. Quick note on "uninstall"
61. Introducing istioctl
62. Istio Profiles
63. Installing addons
64. Notes on the upcoming video
65. Tuning Profiles
66. Note on the upcoming video
67. Default vs Demo Profiles - CPU and Memory
68. Generating YAML Manifests
69. Upgrading Istio
70. In-Place Upgrades
71. "Canary Upgrades" (Rolling Upgrades)
72. Live Cluster Switchovers (Alternative to the official upgrade paths)
73. Goodbye!
74. Goodbye

Overview

This devops bootcamp is the first among several series (coming soon!) to start -or advance- your career as DevOPs or SRE (Site Reliability Engineer).

In this course, you will learn about container technology (docker) and container orchestration (kubernetes). Those are a-must-have knowledge for DevOps engineeer, as docker and kubernetes are popular technology and well sought by many companies. You will also learn about GitOps using ArgoCD, and how to use Istio Service Mesh with Envoy proxy to ease the application management.

What We Will Learn

We will learn how to manage application written on microservice architecture. You don't need to know any programming language to works with this course. In fact, this course is not about programming language, and mostly we will works with text files, terminal, or even graphical user interface.

Learn how to reach infrastructure agility, and easier maintenance compared to traditional infrastrucutre (virtual machine, bare metal). With the help of kubernetes, along with other tools that integrates well, maintaining reliable infrasturcture become a skill that everybody can learn (by using this course, for example).

But kubernetes and docker is not the only technology required for DevOps engineer journey. In this course, we will learn real-life infrastructure architecture that leverages several technologies, integrated to kubernetes. They are:

• Nginx : very popular reverse proxy, http load balancer, which is used as traffic gateway, or kubernetes ingress controller

• Sealed secret : secure your username, password, and any other "secret" things on kubernetes. Update and share them safely, since the kubernetes will "seal" them and encrypt them in secure way

• Grafana, Prometheus : for kubernetes & infrastructure data gathering, analytics, and visualization

• Helm : a package manager for kubernetes. Think of zip archive, but kubernetes-style, that can customized

• Chartmuseum : a repository for helm

• ArgoCD : learn GitOps, a subset of DevOps that focusing on automatic infrastructure based on git repository. Works well since most software engineering team will already familiar with git, so they can also leverage the kubernetes power without knowing the kubernetes itself. Collaborate together, and achieve automated application deployment through GitOps with ArgoCD

• Istio & Envoy Proxy : One of the most important item to works with kubernetes. Manage, secure, and monitor your traffic. Add application functionalities without even writing single line of code

• Kiali : Istio user interface to visualize your traffic that runs on kubernetes cluster,and manage them!

• Jaeger : distributed tracing to know how your microservices performs, which node that has problem

• Lens : hate to see the black screen on terminal? Then use this tools to navigate your kubernetes cluster

  
  

Pre-requisites

• laptop with at least 8 GB memory free (so you need at least 16 GB memory)

• or you can use any laptop, since we will learn to use Google Kubernetes Engine (it might has limited free quota if you are new user, but it depends on google)

  
  

Course Curricullum

These are the things that you will learn, in more than 100 lectures!

• what is container and why it so popular

• kubernetes from zero

• declarative kubernetes

• resource monitoring & limiting

• volume binding

• kubernetes secret & configuration map

• integrate and secure nginx on your kubernetes cluster

• automatic horizontal scaling to maintain performance

• how to use and create helm charts

• how to host your own helm repository (for free)

• gitops automatic application synchronization

• automatic configuration synchronization

• provision and manage tls certificate

• distributed tracing

• service mesh (using istio and envoy proxy)

• traffic management on service mesh

• myths / fallacies of distributed system

• opentracing

• opentelemetry

• service mesh visualization

• load balancer

• canary release

• dark launching

• automatic timeout / retry without even writing code

• mutual TLS for security

1. Introduction
2. Welcome to The Course
3. Course Structure
4. Download Source Code & Scripts
5. Tips : How To Get Maximum Value From This Course
6. Machine Requirement
7. First Step To DevSecOps
8. Engineering Evolution
9. DevOps
10. Container Technology
11. Container
12. Docker Hands On
13. Building Docker Image
14. Semantic Versioning
15. Docker Compose
16. Kubernetes Basic
17. Introducing Kubernetes
18. Installing Kubernetes
19. Hello Kubernetes
20. Using Minikube
21. Scaling Pod
22. Declarative Kubernetes
23. Imperative vs Declarative
24. Declarative Kubernetes
25. Declarative Kubernetes - Hello Sample
26. Replica Set
27. Declarative Kubernetes - Update Delete
28. Operating Kubernetes
29. Label
30. Annotation
31. Port Forward
32. Health Check
33. Pod Lifecycle
34. Log
35. Kubernetes User Interface
36. Dashboard
37. Lens
38. Volume
39. Volume - Theory
40. EmptyDir
41. HostPath
42. Local
43. Application Configuration in Kubernetes
44. Configmap
45. Secret
46. Exposing Kubernetes Pod
47. Service
48. Ingress Controller with Nginx
49. Ingress Over TLS
50. Helm - Kubernetes Package Manager
51. Introducing Helm
52. Sealed Secret
53. Observability on Kubernetes
54. Resource Monitoring via Metrics Server
55. Monitoring Prometheus Stack
56. Nginx Via Prometheus
57. Nginx Ingress Controller on Kubernetes
58. Ingress Combination
59. Ingress In Use
60. Autoscaling & Stateful Set
61. Horizontal Autoscaling
62. Stateful Set
63. Stateful Set On Practice
64. Quota & Service Account
65. Resource Quota
66. Namespace Quota
67. Service Account
68. Secure Pod & Repository
69. Security Context
70. Private Repository
71. Using & Creating Helm Charts
72. Creating Helm Chart
73. Chartmuseum
74. Multiple Configurations
75. Github as Helm Repository
76. Multiple Helm Charts
77. GitOps and Problems That It Solves
78. Loan Pig Bottleneck
79. Introducing GitOps
80. GitOps with ArgoCD
81. ArgoCD Synchronization
82. Kubernetes CRD (Custom Resource Definition)
83. Loan Pig Bottleneck Solution
84. Tips : ArgoCD Useful Features
85. ArgoCD Sensitive Data
86. Reloader
87. Managing Certificate on Kubernetes
88. Cert Manager
89. Istio Service Mesh for East-West Traffic
90. East-West Traffic
91. Google Kubernetes Engine (GKE)
92. Tip : Resource Request
93. Observability & Control
94. Install Kube Prometheus
95. Install Nginx
96. Istio Service Mesh
97. Install Istio
98. Enable Sidecar Injection
99. Check Prometheus
100. Kiali
101. Distributed Tracing
102. Distributed Tracing
103. Header Propagation
104. Header Propagation - Opentracing
105. Using Jaeger With Opentracing Data
106. Header Propagation - Opentelemetry
107. Using Jaeger With Opentelemetry Data
108. Istio & East-West Traffic Visualization
109. Prometheus, Grafana, and Istio
110. Using Kiali
111. Tips : Securing Kiali
112. Traffic Management Using Istio & Envoy Proxy
113. Traffic Routing
114. Istio & Nginx Combination
115. Istio Traffic Management
116. Load Balancer
117. Canary Release
118. Istio Virtual Service
119. Istio Destination Rule
120. Dark Launching
121. Fallacies of Distributed System
122. Fault Injection
123. Fault Injection - Delay
124. Fault Injection - Abort
125. Fault Injection - Conditional Abort
126. Handling HTTP Failures With Istio & Envoy Proxy
127. HTTP Timeout
128. HTTP Retry
129. Circuit Breaker - Theory
130. Circuit Breaker - Hands On
131. Securing East-West Traffic on Kubernetes Cluster
132. Mutual TLS - Theory
133. Enabling Istio Mutual TLS on Kubernetes
134. Mutual TLS - Hands On
135. Choosing Node for Pod
136. Node Selector
137. Node Affinity
138. Inter Pod Affinity
139. Pod Topology Spread
140. Cost Optimization
141. Cost Optimization
142. Managing Cloud Infrastructure From Kubernetes
143. Managing Cloud Infrastructure From Kubernetes
144. Resources & References
145. Download Scripts & Source Codes
146. Bonus Lecture

In this course, we’re going to learn how to Design and Build Cloud-Native Apps with Microservices Architecture, Kubernetes Deployments, Communications, Backing Services, CI/CD pipelines and Monitoring Patterns and Best Practices.

Cloud-native is a huge topic that need to organize how to digest all topics well. We will follow Cloud-Native Trial Map that starts with Containerization and Orchestrations, and continues with CI/CD, Service Meshes, Scalability, Distributed Databases.. In every step, we will follow Cloud-native Pillars, with learning Cloud-Native architecture and visit Cloud-Native tools, explore and understand these tools, design architecture with these tools and finally develop +20 Hands-on real-world project on Kubernetes clusters.

Cloud-Native Pillars Map – The Course Map

Here you can find our course map about the "Cloud-Native Pillars":

• Microservices

• Containers

• Orchestrators

• Communications (Services Mesh)

• Backing Services (K8s Databases, Caches, Message Brokers)

• Scalability (HPA, KEDA)

• Devops CI/CD IaC GitOps

• Monitoring & Observability

During the whole course we will follow these Cloud-Native Pillars with design and implementation of architectures.

Microservices:

Understand the basics of microservices architecture, its benefits, and how to design and develop sample microservices applications. We will learn, explore, design and develop sample microservice applications.

Containers:

We will containerize the microservices. We will learn to containerize our microservices using cloud-native tools such as Docker and containerd.

Orchestrators:

We will orchestrate these containers with learning and using Container Orchestrators like Kubernetes, docker swarm and so on. We will gain hands-on experience with container orchestration platforms like Kubernetes and Docker Swarm to manage your containerized applications.

Communications:

After that we will see how to communicate between Kubernetes pods using Service Meshes like istio. We will Discover how to use service meshes like Istio to facilitate communication between Kubernetes pods.

Backing Services:

We will implement Backing Services for our architecture, will examine Backing Services in 3 sub categories: Databases, Distributed Caches, Message Brokers. We will learn how to deploy and integrate backing services such as databases, caches, and message brokers into your Kubernetes cluster.

Scalability:

We will auto-scale our applications into Kubernetes using HPA and KEDA. We will Implement auto-scaling for our applications in Kubernetes using Horizontal Pod Autoscaler (HPA) and Kubernetes Event-driven Autoscaling (KEDA).

Devops CI/CD:

We will implement DevOps, CI/CD pipelines, IaC, GitOps principles into our architecture using cloud-native tools like GitHub Actions, Terraform, ArgoCD and so on.

Monitoring:

We will implement Monitoring and Observability tools like Prometheus, Grafana, ELK stack into our Kubernetes cluster and perform best practices for cloud-native observability.

All these steps we will not only explore cloud-native tools but also explore Cloud Serverless services like AWS Lambda in microservices, AWS Fargate in orchestrators, Backing Services like Amazon DynamoDB, Azure CosmosDB, Service Buses - Azure Service Bus, Amazon Eventbridge and so on.

Way of Learning – The Course Flow

The learning methodology will be;

• Learn -> Explore -> Design -> Hands-on

We will learn Cloud-Native architectures and visit Cloud-Native tools, explore and understand these tools. And design architecture with using these tools and lastly we will perform hands-on labs to practice tools and cloud-native architectures.

Hands-on Projects

During the course, we'll have a series of hands-on labs for each Cloud-Native Pillar to reinforce your understanding and provide practical experience.

• Hands-on: Develop a RESTful Microservices with CRUD

• Hands-on: Containerize .Net Microservices with Docker

• Hands-on: Deploy Microservices to Kubernetes

• Hands-on: Deploy Microservices to Kubernetes with Helm Charts

• Hands-on: Deploy Microservices to Kubernetes with Service Mesh Istio and Envoy

• Hands-on: Deploy CockroachDB in a Single Kubernetes Cluster with Minikube

• Hands-on: Deploy Cloud-Native Redis Cache on a Kubernetes Cluster with Minikube

• Hands-on: Deploy Cloud-Native Kafka Message Brokers on a Kubernetes Cluster with Minikube

• Hands-on: Auto-scaling Kubernetes Pods (VPA,HPA,KEDA) with Minikube

• Hands-on: Deploy Microservices on Amazon EKS Fargate

• Hands-on: Terraform IaC provision AWS EC2 instance

• Hands-on: GitHub Actions CI/CD for Build & Push Docker Images to DockerHub

• Hands-on: Kubernetes Monitoring with Prometheus and Grafana

Also we will see AWS Serverless Labs to show how cloud-native architectures works on fully cloud serverless services, especially for AWS services:

• Hands-on: Deploy ProductService Container to AWS Apprunner

• Hands-on: Building RESTful Microservices with AWS Lambda, API Gateway and DynamoDB

• Hands-on: Amazon SNS Notifications Topic Subscribe From AWS Lambda

These hands-on labs will provide you with practical experience in applying the concepts, tools, and best practices you've learned throughout the course.

Course Target

This course has 1 main target:

• to be a decision-maker as a software developer/architect in cloud-native architecture boards.

This course is designed for software developers and architects who are interested in learning about cloud-native technologies  and how to apply them in real-world scenarios.

• Hands-on Design and Development Activities

• Apply best practices with cloud-native microservices design patterns and principles

• Explore and Practice with cloud-native tools, understand when and where to use these tools

• Prepare for Software Architecture Interviews

• Prepare for System Design Architecture Interview exams.

By the end of this course, you will gain real-world experience, you will have a solid understanding of the cloud-native ecosystem and will be ready to design, build, and deploy your own cloud-native applications using microservices, Kubernetes, service meshes, CI/CD pipelines, and more.

1. Introduction
2. Introduction
3. Cloud Types: Private/On-premises, Public and Hybrid Cloud
4. Multi-Cloud Strategy
5. Evolution of Cloud Platforms: Cloud Hosting Models: IaaS - CaaS - PaaS - FaaS
6. Cloud-Native Application Architecture
7. Evolution of Application Architectures: Monolithic, Microservices, Serverless
8. Deep Dive into Cloud-Native Pillars - Course Section Flow
9. Way of Learning - The Course Flow
10. Hands-on Projects
11. How to Follow the Course & Course Slides
12. Introduction to Cloud-Native - What is Cloud-Native Architecture ?
13. What is Cloud-Native ?
14. Cloud Native Definition from CNCF
15. What Is Cloud Native Architecture ?
16. Cloud Native Architecture Design Principles and Key Characteristics
17. Benefits of Cloud-Native Architectures
18. Challenges of Cloud-Native Architectures
19. The Cloud Path of Legacy Applications - Modernization of Legacy Apps with Cloud
20. Cloud-Native Quiz
21. Cloud-Native Fundamentals - The Conway's Law and 12 Factor App
22. Introduction - Cloud-Native Fundamentals - Conway's Law and 12 Factor App
23. The Conway's Law
24. The impact of Conway's Law on Cloud-Native Microservices
25. 12-Factors - The Twelve-Factor Application
26. I. Codebase - The Twelve-Factor Application
27. II. Dependencies - The Twelve-Factor Application
28. III. Config - The Twelve-Factor Application
29. IV. Backing services - The Twelve-Factor Application
30. V. Build, release, run - The Twelve-Factor Application
31. VI. Processes - The Twelve-Factor Application
32. VII. Port binding - The Twelve-Factor Application
33. VIII. Concurrency - The Twelve-Factor Application
34. IX. Disposability - The Twelve-Factor Application
35. X. Dev/prod parity - The Twelve-Factor Application
36. XI. Logs - The Twelve-Factor Application
37. XII. Admin processes - The Twelve-Factor Application
38. The Conway's Law and 12 Factor App Quiz
39. Cloud-Native Deep Dive - Landscape, Trial Map and Pillars
40. Introduction - Cloud-Native Deep Dive - Landscape, TrialMap and Pillars
41. Cloud Native Computing Foundation (CNCF)
42. Quick Tour on Cloud Native Computing Foundation (CNCF)
43. What Is the CNCF Landscape ?
44. Deep Dive into CNCF Landscape Categories
45. Complicated with CNCF Projects ? - Funny Break
46. CNCF Cloud Native Trail Map
47. The Four Pillars of Cloud-Native Applications
48. All Cloud Native Pillars - Extended for Course Structure
49. Cloud-Native Landscape, TrialMap and Pillars Quiz
50. Pillar1: Microservices
51. Introduction to Pillar1: Microservices
52. 12-Factor App and Cloud-native Trial Map - Microservices
53. Evolution of Architectures; Monolithic, Microservices, Serverless
54. What are Microservices ?
55. What is Microservices Architecture ?
56. Microservices Characteristics
57. Benefits of Microservices Architecture
58. Challenges of Microservices Architecture
59. When to Use Microservices Architecture - Best Practices
60. When Not to Use Microservices - Anti-Patterns of Microservices
61. Monolithic vs Microservices Architecture Comparison
62. The Database-per-Service Pattern - Polygot Persistence
63. Explore: Languages and Frameworks for Microservices
64. Explore: Cloud-Native Microservices Frameworks
65. Explore: Cloud Managed and Serverless Microservices Frameworks
66. Design: Cloud-Native Microservices Architecture - Way of Learning
67. Understand E-Commerce Domain: Analysis and Decompose E-Commerce Microservices
68. Identifying and Decomposing Microservices for E-Commerce Domain
69. Design: Cloud-Native E-commerce Microservices Architecture
70. Choose Microservices Language and Frameworks for Cloud-Native Microservices
71. Reference Project: .Net Microservices - Cloud-Native E-commerce App
72. Reference Project: AWS Serverless Microservices - Cloud-Native E-commerce App
73. Pillar1: Microservices Quiz
74. Hands-on: Develop a RESTful Microservices with CRUD endpoints
75. Introduction - Hands-on: Develop a RESTful Microservices with CRUD endpoints
76. Primary Programming Languages and Frameworks among Microservices Developers
77. Why .Net for Microservices Development ?
78. Install Prerequisites
79. Developing Product Microservices
80. Run the Application - Product Microservices
81. Create Product Microservices with AWS Serverless Services: AWS Lambda, API Gw
82. Hands-on: Create Product Microservices with AWS Lambda, API Gateway and DynamoDB
83. Pillar2: Containers
84. Introduction to Pillar2: Containers
85. 12-Factor App and Cloud-native Trial Map - Containers
86. Evolution of Cloud Platforms: Cloud Hosting Models: IaaS - CaaS - PaaS - FaaS
87. What are Container ?
88. Why use Containers for developing Cloud-native Microservices ?
89. Best Practices of using Containers
90. How Containers Works ?
91. What is Container Runtimes ?
92. What is a Container Registry ?
93. Containerization: Running Microservices in Containers
94. What is Docker ?
95. Docker Containers, Images, and Registries
96. Docker Architecture
97. Explore Container tools: Container Runtimes, Registries, Deployments
98. Explore: Container Registries
99. Explore: Container Deployment Options
100. Explore: Cloud Container Services: Abstraction Level of Container Deployments
101. Explore The Most Popular Container Images: Redis, Postgres, ElasticSearch, Kafka
102. Design: Cloud-Native E-commerce Microservices Architecture with Containers
103. Reference Project: .Net Microservices - Cloud-Native E-commerce App
104. Build and Run Microservices with Docker Compose
105. Pillar2: Containers Quiz
106. Hands-on: Containerize .Net Microservices with Docker
107. Introduction - Hands-on: Containerize .Net Microservices with Docker
108. Install Prerequisites
109. Write Dockerfile for Product Microservices
110. Create Docker Image for Product Microservices
111. Run Docker Image for Product Microservices
112. Push Docker Image to Docker Hub for Product Microservices
113. Deploy Container to Cloud: AWS Apprunner, Google Cloud Run, Azure Container Inst
114. Prepare your AWS Environment: AWS Account, IAM User, Programmatic Access Key
115. Download and Configure AWS CLI for Programmatic Access
116. Hands-on: Pushing Docker Image to Amazon Elastic Container Registry (ECR)
117. Deploy ProductService Container to AWS AppRunner
118. IMPORTANT - CLEAR AWS RESOURCES
119. Pillar3: Container Orchestrators
120. Introduction to Container Orchestrators
121. 12-Factor App and Cloud-native Trial Map - Container Orchestrators
122. Cloud-native Trial Map - Container Orchestrators
123. Why need Orchestrator for Containers ?
124. What are Container Orchestrators ?
125. Container Orchestrators Usage for Cloud-native Microservices
126. Best Practices of using Container Orchestrators
127. How Container Orchestrators works ?
128. Explore: Container Orchestrator tools: Kubernetes, Docker Swarm, Apache Mesos
129. Explore: Cloud Container Orchestrator tools: EKS, GKS, AKS, Red Hat OpenShift
130. Datadog Container Reports: Kubernetes is defacto standard for Containers
131. Design: Cloud-Native E-commerce Microservices Architecture with Container Orch
132. Design with Managed Kubernetes Services - Cloud-Native E-commerce Microservices
133. Container Orchestrators Quiz
134. Deep Dive into Kubernetes - Defacto Standart for Containers
135. Introduction - Deep Dive into Kubernetes - Defacto Standart for Containers
136. CNCF 2022 Annual Survey - The year cloud native became the new normal
137. Kubernetes is Emerging as the 'Operating System' of the Cloud
138. Cloud-Native Landscape and Trial Map - Kubernetes: Container Orchestrator
139. What Is Kubernetes and why we use them for microservices deployments ?
140. Uses Cases of Kubernetes
141. Kubernetes Architecture
142. Kubernetes Components: Pods, ReplicaSet, Deployments, Service
143. How Kubernetes Works
144. Declarative and Imperative way of Kubernetes
145. Kubernetes Quiz
146. Hands-on: Deploy Microservices to Kubernetes
147. Introduction - Hands-on: Deploy Microservices to Kubernetes
148. Install Minikube and kubectl
149. Getting Started with Minikube
150. ASP.NET Container Expose Port - CONFIGURE TO LISTEN - 0.0.0.0:8080
151. Create a Pod
152. Apply a Pod in K8s
153. Why Should not Create Pod on Kubernetes ?
154. Create a Deployment on Kubernetes
155. Apply a Deployment in K8s
156. Create a Service on K8s
157. Apply a Service in K8s
158. Best Practice of Creating Deployment and Services for Microservices
159. Create Ingress for External Access of Product Microservice
160. Create ConfigMaps and Secrets for Product Microservice
161. Scale a Container Instance in Kubernetes
162. Kubernetes Deploy and Service with Minikube
163. Clean up resources
164. Helm Charts - Managing Kubernetes Applications with Helm
165. Introduction - Helm : Managing Kubernetes Applications with Helm
166. Cloud-Native Landscape and Trial Map - Helm: Managing Kubernetes Applications
167. What is Helm and Helm Charts ?
168. Benefits of Helm Charts and Artifact Hub for Centralized Repository
169. How Helm Charts is works ?
170. Understanding Helm Chart Structure
171. Install and Use Helm
172. Getting Started with Helm: Install and Launch Wordpress Helm from ArtifactHub
173. Hands-on Lab: Deploy Product Microservices with Helm Charts
174. Helm Charts Quiz
175. Pillar4: Cloud-Native Communications
176. Introduction to Cloud-Native Communications
177. 12-Factor App and Cloud-native Trial Map - Cloud-Native Communications
178. Cloud-native Trial Map - Cloud-Native Communications
179. Communications in Cloud-Native Architectures
180. Microservices Communication Types: Synchronous or Asynchronous Communication
181. Microservices Communication Styles: Request-Driven or Event-Driven Architecture
182. Microservices Synchronous Communications and Best Practices
183. Designing HTTP based RESTful APIs for Microservices
184. gRPC: High Performance Remote Procedure Calls
185. How gRPC works ?
186. gRPC Usage in Microservices Communication
187. CN Communication Patterns: API Gateway Pattern
188. A Request Flow of API Gateway Pattern
189. CN Communication Patterns: Service Registry/Discovery Pattern
190. CN Communication Patterns: Sidecar Pattern
191. CN Communication Patterns: Service Mesh Pattern
192. Service Mesh Communication in Cloud-Native Microservices
193. Explore: CN Communication tools: Service Proxy (envoy), API Gateway(kong)
194. Explore: CN Communication tools: Service Proxy (envoy, nginx, haproxy)
195. Explore: CN Communication tools: API Gateway(kong, krakenD, kubeGateway)
196. Explore: CN Communication tools: Service Meshes (istio, linkerd)
197. Explore: Cloud Serverless Communication tools: AWS, Azure Service Proxy, API Gw
198. Service Meshes are still early and Istio dominates usage
199. Design: Cloud-Native E-commerce Microservices Architecture with Service Meshes
200. Design with Cloud Managed Services - AWS API Gateway, Service Mesh

Welcome to course "Deploying Microservices to Kubernetes and AKS". This course is designed to teach you the best practices for building microservices with .Net Core using the Clean Architecture pattern.

This course covers everything you need to know to get started with microservices development in .Net Core. I'll cover the basics of microservices, introduce you to the Clean Architecture pattern, and show you how to build microservices using .Net Core.

This course includes complete hands-on experience that will give you the practical experience you need to master microservices development. You'll learn how to create a project using the Clean Architecture pattern, how to implement Domain-Driven Design (DDD) principles, and how to build and deploy your microservices using Docker and Kubernetes.

By the end of the course, you'll be able to confidently build and deploy your own microservices using .Net Core and Clean Architecture. You'll have a deep understanding of the concepts behind microservices and Clean Architecture, and be able to apply them to real-world projects.

Whether you're a seasoned .Net developer or just starting out with microservices, this course is the perfect way to get started. Sign up today and start building your microservices with .Net Core and Clean Architecture!

Microservices are a design pattern in which applications are composed of independent modules that communicate with each other within well defined boundaries. This makes it easier to develop, test, and deploy isolated parts of your application. If you are coming on this course directly, I suggest follow the Learning path as mentioned below to understand the entire picture.

Disclaimer:- Assuming you have already completed the prerequisite courses listed below in bold letters, as this course cannot be taken as a stand-alone course. Without the foundational knowledge and skills provided in those courses, you may struggle with understanding the API setup and overall flow of the course.

1. Getting Started with Microservices using Clean Architecture

2. Securing Microservices using Identity Server 4

3. Implementing Cross Cutting Concerns

4. Versioning Microservices

5. Building Angular Application for MicroServices

6. Deploying Microservices to Kubernetes and AKS (Current Course)

In the previous section, you gained extensive knowledge of technologies while designing Microservices and implementing Identity Server. As part of that learning journey, you likely designed a Microservices module using clean architecture.

In this section, we will delve into a variety of techniques for hosting your solution, both on bare metal machines and in the cloud. Specifically, we will start by hosting these containers on a local Kubernetes cluster and then move on to the Azure Kubernetes Service (AKS). Along the way, we will explore writing simple, plain YAML files with different configurations and deploying them.

To enhance the reusability and reduce the maintenance overhead of managing multiple YAML files for different services, we will also dive into Helm Templates. They streamline the deployment module by providing a more organized approach.

Furthermore, we will enable Service Mesh using Istio. This enables the implementation of sidecar patterns to enhance the monitoring capabilities of our pods. In the context of Istio's service mesh architecture, the sidecar pattern plays a crucial role. With the sidecar pattern, each microservice is accompanied by an additional sidecar proxy container, such as Envoy, which acts as a communication intermediary.

Grafana and Prometheus are popular monitoring and observability tools that can be integrated with Istio to enhance the visibility of your service mesh. The sidecar pattern enables seamless integration of these tools. The sidecar proxy container intercepts network traffic between microservices, allowing it to collect telemetry data, such as metrics, traces, and logs.

Prometheus, as a monitoring and alerting toolkit, can be deployed as a sidecar within each microservice or as a separate container alongside the sidecar proxy. It collects metrics from the sidecar proxies and other components of the service mesh, providing valuable insights into the performance and behavior of the microservices.

Grafana, a powerful visualization and analytics platform, can be utilized to create interactive dashboards based on the metrics collected by Prometheus. These dashboards offer a real-time view of the service mesh, allowing you to monitor traffic patterns, latency, error rates, and other key indicators. Grafana's integration with Prometheus enables efficient data analysis and visualization, facilitating effective decision-making and troubleshooting.

By combining the sidecar pattern with Grafana and Prometheus, Istio enables comprehensive observability and monitoring capabilities within the service mesh. This integration empowers operators and developers to gain valuable insights into the behavior of their microservices, detect anomalies, and ensure the overall health and performance of the system.

This course is part of our comprehensive Microservices series, where you will gain in-depth knowledge of every aspect related to Microservices. Throughout this learning path, you will connect the dots using various technologies and tools. "Deploying Microservices to Kubernetes and AKS" is the sixth edition of this series, focusing on the following key implementations:

• Introduction

• Introduction

• Architectural Overview

• Branching Strategy

• Going back in time

• K8s Architecture

• What K8s can do

• Kubernetes Setup

• Enabling Kubernetes

• K8s Components

• Creating Catalog Api Yaml

• Adding Brands and Types sections

• Creating Mongo ConfigMap

• Catalog Db Yaml Creation

• Catalog db Secret Creation

• Docker tag Catalog Api image

• Catalog Api and Db Created

• Setting up Kubernetes Dashboard

• Fixing Container config issue

• Kubernetes Lens

• Fixing Checkout Issue

• Azure Setup

• Azure Container Registry setup

• Docker ACR Tagging

• Pushing Images to ACR

• Creating Azure Container Registry Secret

• AKS Creation Error

• Fixing AKS Creation Issue

• Merging AKS Credentials with local Kube Config

  
  

• Helm Installation

• Introduction

• Helm Installation

• Understanding Catalog Helm Template

• Understanding Basket Helm Template

• Understanding Discount Helm Template

• Understanding Ordering Helm Template

• Understanding Infrastructure Helm Templates

• Understanding Powershell Script to install and uninstall components

• Helm Installation Image Pull Issue

• Fixing Azure Login server issue

• Ocelot Issue

  
  

• Enabling Service Mesh using Istio

• Introduction

• Istio features

• Enabling Istio

• Verifying Istio in Kube Lens

• Disabling Sidecar injection

• Enabling Kiali Dashboard

• Visualizing Catalog pod traffic

• Visualizing Grafana and Prometheus Dashboard

  
  

• Thank You

• Thank You

1. Introduction
2. Introduction
3. Architectural Overview
4. Branching Strategy
5. Going back in time
6. K8s Architecture
7. What K8s can do
8. Kubernetes Setup
9. Enabling Kubernetes
10. K8s Components
11. Creating Catalog Api Yaml
12. Adding Brands and Types sections
13. Creating Mongo ConfigMap
14. Catalog Db Yaml Creation
15. Catalog db Secret Creation
16. Docker tag Catalog Api image
17. Catalog Api and Db Created
18. Setting up Kubernetes Dashboard
19. Fixing Container config issue
20. Kubernetes Lens
21. Azure Setup
22. Azure Container Registry setup
23. Docker ACR Tagging
24. Pushing Images to ACR
25. Creating Azure Container Registry Secret
26. AKS Creation Error
27. Fixing AKS Creation Issue
28. Merging AKS Credentials with local Kube Config
29. Helm Installation
30. Introduction
31. Helm Installation
32. Understanding Catalog Helm Template
33. Understanding Basket Helm Template
34. Understanding Discount Helm Template
35. Understanding Ordering Helm Template
36. Understanding Infrastructure Helm Templates
37. Understanding Powershell Script to install and uninstall components
38. Helm Installation Image Pull Issue
39. Fixing Azure Login server issue
40. Ocelot Issue
41. Enabling Service Mesh using Istio
42. Introduction
43. Istio features
44. Enabling Istio
45. Verifying Istio in Kube Lens
46. Disabling Sidecar injection
47. Enabling Kiali Dashboard
48. Visualizing Catalog pod traffic
49. Visualizing Grafana and Prometheus Dashboard
50. Thank You
51. Thank You

Become an Istio and Kubernetes professional and learn one of employer's most requested skills nowadays!

This comprehensive course is designed so that students, Kubernetes users, developers, engineers... can learn Istio Service Mesh for Kubernetes from scratch to use it in a practical and professional way. Never mind if you have no experience in the topic, you will be equally capable of understanding everything and you will finish the course with total mastery of the subject.

After several years working as an Engineer, I have realized that nowadays mastering Istio Service Mesh is very necessary in Kubernetes and other DevOps applications. Knowing how to use this service mesh can give you many job opportunities and many economic benefits, especially in the world of development.

The big problem has always been the complexity to perfectly understand Istio it requires, since its absolute mastery is not easy. In this course I try to facilitate this entire learning and improvement process, so that you will be able to carry out and understand your own projects in a short time, thanks to the step-by-step and detailed examples of every concept.

With more than 7 exclusive hours of video, this comprehensive course leaves no stone unturned! It includes both practical exercises and theoretical examples to master Istio. The course will teach you how to master this service mesh in a practical way, from scratch, and step by step.

We will start with the installation of Istio on your computer, regardless of your operating system and computer.

Then, we'll cover a wide variety of topics, including:

• Introduction to Istio, Service Mesh and course dynamics

• Download and Install Install Istio and configuring it

• General familiarization with Istio Architecture and Components

• Observability, Metrics (with Prometheus and Grafana) and Traffic Management

• Secure Service-to-Service Communication: mutual TLS and fine-grained access control policies

• Working with Istio Advanced Features: service mesh expansion for non-Kubernetes environments, Rate limiting, Traffic shaping, Istio's retry, timeout features...

• Istio Best Practices and Troubleshooting

• Following from scratch Istio Use Cases and Istio Real Time Projects

• Mastery and application of absolutely ALL the functionalities of Istio Service Mesh

• Practical exercises, complete project and much more!

In other words, what I want is to contribute my grain of sand and teach you all those things that I would have liked to know in my beginnings and that nobody explained to me. In this way, you can learn to conduct a wide variety of real examples and make versatile and complete use of Istio. And if that were not enough, you will get lifetime access to any class and I will be at your disposal to answer all the questions you want in the shortest possible time.

Learning Istio and Kubernetes has never been easier. What are you waiting to join?

1. Introduction to Service Mesh
2. Course Introduction
3. Introduction to Microservices and its challenges
4. Introduction to service mesh and its benefits
5. Overview of Istio and its role in service mesh architecture
6. Istio Architecture and Components
7. Overview of the key components in Istio
8. Understanding the data plane and control plane
9. Installing and Configuring Istio
10. Considerations and Specifications
11. Setting up a Kubernetes cluster for Istio deployment
12. Installation and configuration
13. Configuring Istio control plane and data plane components
14. Observability and Metrics with Istio
15. Leveraging Istio's observability features for monitoring and logging
16. Collecting and visualizing metrics with Prometheus and Grafana
17. Distributed tracing with Zipkin and Istio
18. Traffic Management with Istio
19. Understanding Istio's traffic routing and load balancing features
20. Using Istio to implement A/B testing and canary deployments
21. Configuring circuit breakers and fault injection with Istio
22. Secure Service-to-Service Communication
23. Introduction to mTLS (mutual TLS) and its role in Istio security
24. Implementing Mutual TLS in Istio-1
25. Implementing Mutual TLS in Istio-2
26. Implementing fine-grained access control policies with Istio
27. Istio Service Mesh Advanced Features
28. Using Istio's service mesh expansion for non-Kubernetes environments
29. Rate Limit Ingress Gateway Part-1
30. Rate Limit Ingress Gateway Part-2
31. Rate Limit Egress Gateway Part-1
32. Rate Limit Egress Gateway Part-2
33. Implementing rate limiting and traffic shaping with Istio
34. Applying resilience patterns with Istio's retry and timeout features
35. Istio Best Practices and Troubleshooting
36. Best practices for managing Istio configuration and policies
37. Best Practices for Istio deployment in Projection
38. Designing and structuring microservices with Istio in mind
39. Troubleshooting common issues and debugging techniques
40. Future Trends and Conclusions
41. Future of Service Mesh and Istio
42. Istio Learning Recap-1
43. Istio Learning Recap-2
44. Istio Resources
45. Istio Use Cases and Project
46. Istio Use Cases
47. Istio Real Time Project
48. Course closure