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

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.