What you'll learn:
- Cloud-Native Pillars: Microservices, Containers, Orchestrators, Communications, Backing Services, Scalability, Devops CI/CD, Monitoring
- Design and Develop Microservices Architecture using aspnet web minimal apis.
- Containerize microservices using cloud-native tools such as Docker and containerd.
- Orchestrate containers using Container Orchestrators like Kubernetes, docker swarm.
- Deploy and manage microservices on Kubernetes.
- Discover service mesh and Kubernetes-native solutions for microservices orchestration.
- Communicate between Kubernetes pods using Service Meshes like Istio.
- Implement Backing Services in Cloud-Native: Databases, Distributed Caches, Message Brokers
- Auto-scaling applications in Kubernetes using Horizontal Pod Autoscaler (HPA) and Kubernetes Event-driven Autoscaling (KEDA).
- Implement DevOps, CI/CD pipelines, IaC, GitOps principles into architecture using Cloud-native tools like Github Actions, Terraform, ArgoCD.
- Monitoring and Observability with Prometheus, Grafana, ELK stack into Kubernetes cluster
- Learn cutting-edge Kubernetes patterns and serverless
- Deploy Redis and Kafka nodes on Kubernetes cluster using Minikube
- Develop 10+ Hands-on lab using Cloud-native Landscape tools
- Develop Serverless Architecture using AWS Cloud services
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.
