Cloud Native Applications The Modern Stack #259013

Upon completion of this course, participants will be able to:

• Articulate the core principles and benefits of cloud-native architecture (microservices, DevOps, continuous delivery).

• Containerize applications using Docker and manage them through their lifecycle.

• Orchestrate containers at scale using Kubernetes, including deployment, scaling, and management.

• Design and develop loosely-coupled, API-driven microservices.

• Implement a CI/CD pipeline to automate testing, building, and deployment of cloud-native applications.

• Integrate supporting technologies like service mesh (Istio/Linkerd), serverless platforms, and observability tools.

This course is designed for software development professionals involved in building, deploying, and managing modern applications.

• Software Developers and Application Architects

• DevOps Engineers and Site Reliability Engineers (SREs)

• Platform Engineers and Infrastructure Architects

• Technical Leads and Engineering Managers

• IT Professionals looking to transition into modern development practices

• Pre-assessment
• Live group instruction
• Use of real-world examples, case studies and exercises
• Interactive participation and discussion
• Power point presentation, LCD and flip chart
• Group activities and tests
• Each participant receives a binder containing a copy of the presentation
• slides and handouts
• Post-assessment

Day 1: The Cloud-Native Foundation

• Morning:

  • Module 1: Introduction to Cloud Native: What it is, why it matters, and the CNCF landscape. The 12-Factor App methodology.

  • Module 2: The Container Revolution: Introduction to Docker. Understanding images, containers, and registries.

• Afternoon:

  • Module 3: Hands-On with Docker: Building Dockerfiles, creating images, and running containers.

  • Lab 1: Containerizing a Monolithic Application: Participants will package a simple application and its dependencies into a Docker container.

  • Day 1 Recap: The building block of cloud native – the container.

Day 2: Orchestration with Kubernetes

• Morning:

  • Module 4: Kubernetes Fundamentals: Understanding the control plane, nodes, pods, deployments, and services.

  • Module 5: The Kubernetes API and YAML Manifests: Declarative vs. imperative management.

• Afternoon:

  • Module 6: Deploying and Managing Applications on Kubernetes: Using kubectl, exposing services, and managing application lifecycle.

  • Lab 2: Deploying a Multi-Tier Application on Kubernetes: Participants will deploy a web app with a database using Kubernetes manifests.

  • Day 2 Recap: Taming container sprawl with orchestration.

Day 3: Microservices & API-Driven Development

• Morning:

  • Module 7: Designing Microservices: Decomposition patterns, bounded contexts, and domain-driven design (DDD).

  • Module 8: Communication Patterns: Synchronous (REST, gRPC) and asynchronous (message queues) communication between services.

• Afternoon:

  • Module 9: API Gateways and Management: The role of an API gateway in a microservices architecture.

  • Lab 3: Breaking the Monolith: Refactoring a part of the application from Day 2 into a separate microservice and establishing communication.

  • Day 3 Recap: Building small, focused, and independent services.

Day 4: CI/CD & GitOps

• Morning:

  • Module 10: The CI/CD Pipeline for Cloud Native: Automating build, test, and deployment processes.

  • Module 11: Introduction to GitOps: Using Git as a single source of truth for declarative infrastructure and applications.

• Afternoon:

  • Module 12: Hands-On with CI/CD Tools: Building a pipeline with popular tools (e.g., Jenkins, GitLab CI, or GitHub Actions) to deploy to Kubernetes.

  • Lab 4: Building a GitOps Pipeline: Automating the deployment of the application using a GitOps tool like ArgoCD or Flux.

  • Day 4 Recap: Automating everything for speed and reliability.

Day 5: Advanced Patterns & The Full Picture

• Morning:

  • Module 13: Observability: Implementing logging, metrics, and tracing in a distributed system (e.g., with Prometheus and Grafana).

  • Module 14: Service Mesh & Security: Introduction to Istio/Linkerd for traffic management, security, and observability.

• Afternoon:

  • Module 15: Serverless and Functions-as-a-Service (FaaS): Where serverless fits in the cloud-native stack.

  • Capstone Project: Participants will design and document the architecture for a cloud-native application, incorporating all elements learned during the week.

  • Course Conclusion: Final review, trends, and awarding of certificates.