Cloud Native Application Architecture

Lesson One- Welcome to Cloud-Native Fundamentals

• Evaluate the cloud-native ecosystem 
• Explore CNCF (Cloud Native Computing Foundation) and cloud-native tooling

Lesson two - Architecture Consideration for Cloud-Native Applications

• Choose monolith or microservice based-architecture for an application 
• Apply good development practices to an application 
• Consider and evaluate the involved trade-offs for monoliths and microservices 

Lesson three- Container Orchestration with Kubernetes

• Use Docker to package an application and distribute it via DockerHub 
• Differentiate between declarative and imperative Kubernetes management techniques
• Bootstrap a Kubernetes cluster using k3s 
• Explore Kubernetes resources for an application deployment 

Lesson four- Open Source PaaS

• Understand the usage and abstracted components while using a Platform as a Service (PaaS) solution
• Explore application deployment with Cloud Foundry 

Lesson five- CI/CD with Cloud Native Tooling

• Explain CI/CD and its benefits 
• Deploy an application using ArgoCD and a Helm chart
• Apply Continuous Delivery fundamentals using ArgoCD 
• Apply Continuous Integration fundamentals using GitHub Actions 
• Use Helm, as a configuration template manager, to parametrize declarative Kubernetes manifests 

Lesson One Introduction to Message Passing 

• Define message passing 

• Understand the historical context of how and why message passing is used

Lesson two-Refactoring From a Monolith

• Analyze and identify the first service or capability to decompose a monolith 
• Determine the appropriate migration strategy 
• Create a dependency map in order to prioritize how to refactor a service (based on business logic) 
• Apply the strangler pattern for migrating a monolith architecture
• Migrate service from a monolith into its own microservice

Lesson three- Types of Message Passing 

• Identify use cases & implement best practices of REST 
• Identify use cases & implement best practices of message queues
• Identify use cases of gRPC 

Lesson four- Implementing Message Passing 

• Use and apply REST 
• Use and apply gRPC 
• Use and apply Kafka

Lesson five- Message Passing in Production 

• Identify use cases of communication protocol in conjunction with one another 
• Manage the life cycle of communication protocol
• Use OpenAPI

Lesson one -Introduction to Cloud Observability 

• Distinguish between black box and white box monitoring 
• Identify the key tools needed to run a Kubernetes cluster
• Identify the stakeholders involved in observability 

Lesson two- Observability Tools

• Recognize the distinct roles that Prometheus, Grafana, and Jaeger play in observability 
• Successfully install Prometheus, Grafana, and Jaeger on a Kubernetes cluster

Lesson three- SLOs, SLIs, and Error Budgets 

• Identify the role observability plays in modern applications 
• Use error budgets to make observability decisions
• Recognize why we use SLOs and SLIs as metrics 

Lesson four- Tracing

• Distinguish tracing from logging and identify the benefits tracing provides beyond standard logging 
• Identify the basics of how Jaeger helps manage a trace
• Identify the basics of how a span is used when tracing applications 

Lesson five- Building Dashboards

• Create dashboards and panels with various metrics
• Navigate Grafana and set up data sources 

Lesson one- Introduction to Microservices Security

• Understand the difference between microservices security and traditional infrastructure security
• Define microservices security 

Lesson two- Threat Modeling with STRIDE 

• Examine the STRIDE methodology for threat modelling as part of the Software Development Lifecycle (SDLC) 
• Apply the STRIDE methodology to the primary Kubernetes components
• Apply the STRIDE methodology to the primary Docker components 

Lesson three- Docker Attack Surface Analysis and Hardening 

• Apply Docker security properties in-depth, including client, host, and registry, evaluating threat models 
• Implement image signing using Docker content trust to verify the integrity of the image
• Implement CIS benchmarks to harden docker images via docker-bench 

Lesson four- Kubernetes Attack Surface Analysis and Hardening 

• Examine Kubernetes security properties in-depth, including cloud-controller-manager, etc, Kube-Episerver, Kube controller-manager, Kube-proxy and Kube-scheduler 
• Evaluate findings against CIS benchmarks and apply a methodology for hardening and testing changes

Lesson five- Software Composition Analysis

• Examine examples of supply chain tampering with recent Solarwinds incidents and why software analysis composition is vital to the security 
• Examine and remediate common vulnerable libraries and application security vulnerabilities in a Flask application 
• Examine common application security vulnerabilities and provide remediation

Lesson six- Runtime Monitoring and Incident Response 

• Examine security considerations for dangerous commands and ongoing runtime security 
• Define a security response playbook to triage and respond to alerts
• Implement Sysdig Falco as a DaemonSet with a basic rule set to monitor node processes and send to Grafana for visualization and alerting