Top 8 Recommended Istio Service Mesh Self-Study Materials! [November 2024]

IMPORTANT NOTICE BEFORE YOU ENROLL:

This course is not a replacement for the official materials you need for the certification exams. It is not endorsed by the certification vendor. You will not receive official study materials or an exam voucher as part of this course.

In this course, you'll dive deep into Istio, a powerful service mesh designed to simplify and secure the management of microservices in modern cloud-native applications. The course begins by exploring what Istio is, why it's essential for managing microservices, and the key components of its architecture, such as Pilot, Mixer, and Envoy, which work together to handle service discovery, traffic management, and security.

Istio is an open-source service mesh platform designed to simplify and manage the communication between microservices in distributed applications. It provides a way to control how services interact over the network, making it easier to manage complex microservice architectures.

Istio achieves these functions by deploying a sidecar proxy (using Envoy) alongside each service. The sidecar intercepts all network communication, enabling control over traffic without requiring any changes to the actual service code. This makes Istio a powerful tool for managing microservices at scale in cloud-native environments.

You'll gain a solid understanding of how Istio identifies and tracks services within the mesh, manages traffic routing, and enforces security policies, all while providing observability through built-in features like metrics, tracing, and logging. The course also covers critical concepts like mutual TLS, role-based access control (RBAC), and authorization policies, which help secure service-to-service communication in an Istio environment.

Next, you'll explore advanced topics such as traffic management in depth, focusing on Envoy Proxy, virtual services, destination rules, load balancing, and canary deployments using traffic splitting and mirroring. The course also delves into how Istio handles external traffic through gateways and ingress resources, giving you full control over the flow of requests into your microservices.

Additionally, the course addresses the management and configuration of Istio, covering essential configuration files, ConfigMaps, and custom resource definitions (CRDs). You'll learn how to deploy and manage Istio across multiple clusters, inject sidecar proxies into pods, and apply circuit-breaking patterns to improve the reliability of your services.

Throughout the course, real-world use cases and best practices are emphasized, ensuring that you can confidently deploy and manage Istio in production environments.

Whether you're looking to improve service reliability, enhance security, or streamline observability, this comprehensive course will equip you with the skills needed to fully harness the power of Istio in managing microservices at scale.

Thank you

1. Introduction to Istio
2. What is Istio?
3. The Need for Service Mesh
4. Istio Architecture Overview
5. Core Concepts of Istio
6. Service Discovery in Istio
7. Traffic Management in Istio
8. Security in Istio
9. Observability in Istio
10. Traffic Management in Depth
11. Understanding Envoy Proxy
12. Virtual Services and Destination Rules
13. Load Balancing and Failovers
14. Traffic Splitting and Mirroring
15. Security Features in Istio
16. Mutual TLS
17. Role-Based Access Control (RBAC)
18. Authentication Policies
19. Authorization Policies
20. Observability and Monitoring
21. Metrics Collection in Istio
22. Distributed Tracing in Istio
23. Log Aggregation and Access Logs
24. Configuring and Managing Istio
25. Istio Control Plane Overview
26. Understanding Istio Configurations
27. Istio Gateway and Ingress
28. Advanced Istio Concepts
29. Istio Service Mesh Across Multiple Clusters
30. Sidecar Proxy Injection
31. Circuit Breaking in Istio
32. Istio Use Cases and Best Practices
33. Best Practices for Istio Deployment

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

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 Distributed 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

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

IMPORTANT before enrolling:

• Actual Istio Certified Associate (ICA) from LinuxFoundation is Time-based and Performance-based (Lab/practical). And this practice question is just to give a familiarity for real time questions of the exam.

• As current portal is not supporting lab session, only relevant questions with great explanations are updated in this course.

• As real exam is time-based and lab/practical/performance based - you can get real answer only after submission of test and have a looks on how the solution can be helpful to solve the real exam.

Suggestion - For practice lab, you can use your own Kubernetes cluster, and perform the similar exercise on the BookInfo Application, which is already bundled under Istio installation. In case, if you are planning to instructor led training program for the Istio from scratch, feel free to drop message on Instrucor's LinkedIn profile. My team will update you for the next upcoming batches on the same, with details.

Actual Exam - ICA

The Istio Certified Associate (ICA) exam demonstrates a solid understanding of Istio principles, terminology, and best practices in order to set up Istio.

Who is it for?
The ICA is a pre-professional certification designed for engineers, CI/CD practitioners or anyone with special interests in Istio.

What does the ICA Demonstrate?
An ICA can comprehend GitOps patterns including when and why to use them. They understand the precautions to take around tooling for manifest format and packaging, state store systems, and reconciliation engines to adhere to and extend GitOps principles.

Domains and Competencies -

Istio Installation, Upgrade and Configuration (7%)
Using the Istio CLI to install a basic cluster
Customizing the Istio installation with the IstioOperator API
Using overlays to manage Istio component settings
Traffic Management (40%)
Controlling network traffic flows within a service mesh
Configuring sidecar injection
Using the Gateway resource to configure ingress and egress traffic
Understanding how to use ServiceEntry resources for adding entries to internal service registry
Define traffic policies using DestinationRule
Configure traffic mirroring capabilities
Resilience and Fault Injection (20%)
Configuring circuit breakers (with or without outlier detection)
Using resilience features
Creating fault injection

Security Workloads (20%)
Understand Istio security features
Set up Istio authorization for HTTP/TCP traffic in the mesh
Configure mutual TLS at mesh, namespace, and workload levels

Advanced Scenarios (13%)
Understand how to onboard non-Kubernetes workloads to the mesh
Troubleshoot configuration issues

1. Istio installation, upgrade and configuration
2. Traffic Management
3. Resilience and Fault Injection
4. Securing Workloads
5. Advanced Scenarios
6. Multiple Choice Questions