Update Challenges

content/_index.md

@@ -12,6 +12,7 @@ Welcome to dev environment for your Academy
 
 [LearningPaths](/academy/learning-paths/)
 
+[Challenges](/academy/challenges/)
 
 
 {{% /blocks/lead %}}

content/challenges/11111111-1111-1111-1111-111111111111/cncf-auto-scaling-challenge/_index.md

@@ -0,0 +1,9 @@
+---
+title: "CNCF Autoscaling Challenge"
+description: "Learn event-driven autoscaling in Kubernetes. Work with scaled objects in KEDA, monitoring with Prometheus, Open Telemetry & CloudEvents and advanced KEDA configurations."
+themeColor: "#3C494F"
+banner: "11111111-1111-1111-1111-111111111111/images/keda-icon.svg"
+courses: 1
+weight: 1
+type: learning-paths
+---

content/challenges/11111111-1111-1111-1111-111111111111/cncf-auto-scaling-challenge/autoscaling-with-keda/_index.md

@@ -0,0 +1,20 @@
+---
+docType: "Course"
+title: 'Autoscaling with KEDA'
+description: "Design an event-driven autoscaling architecture using KEDA."
+courseTitle: "Autoscaling with KEDA"
+themeColor: "#00B39F"
+lectures: 3
+weight: 1
+---
+
+## Objective
+A challenge to help you set up KEDA and start using it to build real-life applications with event-driven autoscaling in Kubernetes. Learn how to configure KEDA as an autoscaling solution, enabling your workloads to scale based on external metrics such as message queue length, database size, or custom application metrics.
+
+## Prerequisites
+
+**Access to Meshery**: 
+You will need access to a Meshery server, either Self-Hosted or the [Meshery Playground](https://playground.meshery.io/).
+
+**Learn KEDA Concepts**: Study [KEDA's key concepts](https://trainingportal.linuxfoundation.org/learn/course/scaling-cloud-native-applications-with-keda-lfel1014/course-introduction/course-information?page=1), including ScaledObjects, ScaledJobs, and various scalers. The Linux Foundation course provides a comprehensive introduction to these concepts, which are essential for completing the challenge successfully.
+**Learn to use Meshery**: Go through the Mastering Meshery Learning Path to gain proficiency in using Meshery for designing, deploying, and managing your KEDA-based architecture.

content/challenges/11111111-1111-1111-1111-111111111111/cncf-auto-scaling-challenge/autoscaling-with-keda/content/description.md

@@ -0,0 +1,115 @@
+---
+docType: "Chapter"
+id: "What is this Challenge About"
+description: "This competition will challenge you to design an architecture diagram that demonstrates how KEDA can be used to automatically scale applications in a Kubernetes environment based on event-driven metrics. You'll learn how to configure KEDA scalers, how to integrate various event sources, and how to visualize the autoscaling process in a complex microservices architecture. This challenge will deepen your understanding of event-driven autoscaling in cloud-native environments and showcase how KEDA enhances Kubernetes' native scaling capabilities"
+chapterTitle: "What is this Challenge About"
+title: "What is this Challenge About"
+weight: 2
+---
+
+### **Overview**
+
+In this challenge, you will design and implement an event-driven autoscaling solution using [Kubernetes Event-Driven Autoscaling (KEDA)](https://keda.sh/). Your task is to create a deployable design that demonstrates KEDA's capabilities in a microservices architecture. This challenge will test your skills in creating a system that can efficiently respond to fluctuating workloads driven by real-world events.
+
+### **Setting the Stage with KEDA**
+
+KEDA (Kubernetes Event-Driven Autoscaling) is an open-source, lightweight component that extends Kubernetes' autoscaling capabilities. It provides fine-grained autoscaling for event-driven workloads, allowing applications to scale based on the number of events needing to be processed.
+
+KEDA bridges the gap between event-driven architectures and Kubernetes' scaling capabilities. It allows for more efficient resource utilization, faster response times to workload changes, and can significantly reduce costs by scaling to zero when there's no work to be done.
+
+In the modern cloud-native landscape, where applications often need to respond to unpredictable, event-driven workloads, KEDA provides a powerful tool for creating responsive, efficient, and cost-effective Kubernetes deployments.
+
+### **Objective**
+
+Design a KEDA-based autoscaling solution for a microservices application that responds efficiently to fluctuating workloads driven by events.
+
+### **Challenge Steps**
+
+These are necessary steps that must be followed to complete this challenge.
+
+
+#### 1. KEDA Architecture Design
+
+1. First, import KEDA into Meshery and expand on the design, identifying the key components of the KEDA architecture including The **KEDA Operator** deployment, the **Metrics Server** etc. Consider how they interact within your Kubernetes cluster and how to properly represent this interaction in your design.
+
+2. Pay attention to how the KEDA Operator and Metrics Adapter are defined. Consider:
+
+    * Their resource requests and limits.
+    * Any environment variables or configuration options.
+    * Service account and RBAC settings.
+
+
+3. Visualize in your design how these components will interact with your Kubernetes cluster's API server, the Horizontal Pod Autoscaler (HPA), and your application deployments.
+
+#### 2. Application Deployment
+
+1. Add a sample microservices application to your design. It should contain at least **two** services that could benefit from event-driven scaling. How might these services experience varying loads throughout the day?
+
+#### 3. KEDA Custom Resource Definitions
+
+KEDA uses Custom Resource Definitions (CRDs) to define how your services should scale.
+
+1. Utilize at least two of the following KEDA CRDs in your design:
+
+    * scaledobjects.keda.sh (compulsory)
+    * scaledjobs.keda.sh
+    * triggerauthentications.keda.sh
+    * clustertriggerauthentications.keda.sh
+
+2. Create ScaledObject resources for your deployed services.
+
+3. Demonstrate in your design, how an application service would be scaled based on a specific event.
+
+#### 4. Scaler Implementation
+
+Scalers are KEDA's sensors, detecting when it's time to scale your services. They're the pulse of your system, constantly monitoring for events that signal a need for more (or fewer) resources.
+
+1. Implement at least **two** different scalers for your services.
+
+2. You must include either an **HTTP Scaler** or a **Cron Scaler**.
+
+3. Choose additional scalers that fit your application's needs.
+
+**Your design should demonstrate how these scalers respond to various event sources to create a dynamic, event-driven scaling system.**
+
+#### 5. Identify Event Sources in your Design
+
+For this task you’ll identify and incorporate at least two different event sources in your design. KEDA supports a wide variety of event sources, including message queues, databases, and time-based triggers. These event sources will act as the signals for your scalers, dictating when and how your services should scale.
+
+1. Identify at least two event sources in your design.
+
+2. Clearly define the event source for each scaler, explaining how different types of events in your system can trigger scaling actions.
+
+#### 6. The HPA Connection
+
+While KEDA extends Kubernetes' scaling capabilities, it doesn't replace the Horizontal Pod Autoscaler (HPA). Instead, they work together in harmony.
+
+Demonstrate in your design how KEDA integrates with the HPA. Show the flow of how KEDA detects an event, translates it into a metric, and how the HPA uses this to adjust the number of pods.
+
+#### 7. Load Generation
+
+1. Use Meshery's built-in load generator to simulate traffic to your application.
+
+2. Design a testing scenario that demonstrates how your services scale in response to varying loads.
+
+### **Evaluation Criteria**
+
+1. **Functionality**: Your design must be deployable and demonstrate working KEDA autoscaling.
+
+2. **Scalability**: Effective use of KEDA to handle varying workloads.
+
+3. **Event Source Diversity**: Incorporation of multiple, relevant event sources.
+
+4. **Integration**: Clear demonstration of KEDA's interaction with HPA and other Kubernetes components.
+
+5. **Testing**: Thorough load testing with meaningful analysis of results.
+
+### **Submission Guidelines**
+
+1. Provide a detailed architecture diagram of your KEDA implementation.
+
+2. Include explanations for your choice of event sources and scalers as labels in the design.
+
+Remember, KEDA allows for scaling based on a wide range of events, from queue lengths to database metrics. Your design should showcase this versatility while addressing practical scaling scenarios for your chosen application.
+
+Good luck with your KEDA design challenge!

content/challenges/11111111-1111-1111-1111-111111111111/cncf-auto-scaling-challenge/autoscaling-with-keda/content/faq.md

@@ -0,0 +1,22 @@
+---
+docType: "Chapter"
+id: "FAQs"
+description: ""
+chapterTitle: "FAQs"
+title: "FAQs"
+weight: 3
+---
+
+#### Can I participate in a sample challenge?
+
+Yes, we recommend that you participate in our sample challenge.
+
+This challenge enables you to understand how to participate in challenges on Meshery. It comprises detailed information about how questions should be attempted and details about the Meshery judge.
+
+#### Do I need to register for the contest?
+
+Yes, in order to participate in a contest you do need to register for the contest with a Meshery account.
+
+#### How does the ranking work in a contest?
+
+Each problem has an assigned score. Usually a more challenging problem has a higher score. Your objective is to obtain the highest score with the fastest finish time while making as few mistakes as possible.

content/challenges/11111111-1111-1111-1111-111111111111/cncf-auto-scaling-challenge/autoscaling-with-keda/content/getting-started.md

@@ -0,0 +1,24 @@
+---
+docType: "Chapter"
+id: "About KEDA Challenge"
+description: "This competition will challenge you to design and implement event-driven autoscaling for Kubernetes applications using KEDA (Kubernetes Event-driven Autoscaling). You'll learn how to set up KEDA, configure scalers, and optimize autoscaling for various event sources in a microservices architecture."
+chapterTitle: "About KEDA Challenge"
+title: "About KEDA Challenge"
+weight: 1
+---
+
+### **Eligibility Criteria**
+
+This challenge is open for all.
+
+### **The Rules**
+
+- This contest is for individuals; teams are not allowed.
+- Any competitor found cheating will be disqualified and banned from future contests.
+
+### **Scoring**
+1. Participants are ranked by score. Your score is determined by the following criteria:
+    * Correct implementation of KEDA scalers (40%)
+    * Efficiency of autoscaling configuration (30%)
+    * Integration with at least two different event sources (20%)
+    * Documentation and explanation of your solution (10%)

content/challenges/11111111-1111-1111-1111-111111111111/cncf-observability-challenge-with/_index.md

@@ -0,0 +1,9 @@
+---
+title: "CNCF Observability Challenge with Jaeger"
+description: "Join this CNCF Challenge and showcase your skills in designing a distributed tracing architecture using Jaeger."
+themeColor: "#3C494F"
+banner: "11111111-1111-1111-1111-111111111111/images/jaeger-icon-black.svg"
+courses: 1
+weight: 2
+type: learning-paths
+---

content/challenges/11111111-1111-1111-1111-111111111111/cncf-observability-challenge-with/distributed-tracing-with-jaeger/_index.md

@@ -0,0 +1,27 @@
+---
+docType: "Course"
+title: 'Distributed Tracing with Jaeger'
+description: "Design an event-driven autoscaling architecture using KEDA."
+courseTitle: "Distributed Tracing with Jaeger"
+themeColor: "#00B39F"
+lectures: 3
+weight: 1
+---
+
+
+---
+
+## Objective
+A course to help you setup a service-mesh and start using it to build real-life applications using Meshery
+as the cloud native management plane.
+
+## Prerequisites
+
+[**Install Jaeger**:](https://www.jaegertracing.io)
+Jaeger maps the flow of requests and data as they traverse a distributed system. These requests may make calls to multiple services, which may introduce their own delays or errors.
+
+**Run Jaeger**:
+Your applications must be instrumented before they can send tracing data to Jaeger backend. Check the Client Libraries section for information about how to use the OpenTracing API and how to initialize and configure Jaeger tracers.
+
+**Manage Jaeger**:
+Wrangle your cluster and design with Jaeger.

content/challenges/11111111-1111-1111-1111-111111111111/cncf-observability-challenge-with/distributed-tracing-with-jaeger/content/description.md

@@ -0,0 +1,13 @@
+---
+docType: "Chapter"
+id: "About Challenge"
+description: "This competition will challenge you to design an architecture diagram that demonstrates how Jaeger can be used to trace requests across a complex microservices architecture. You'll learn how to instrument your code, how to collect and analyze trace data, and how to visualize and interpret the results."
+chapterTitle: "About Challenge"
+title: "About Challenge"
+weight: 2
+---
+
+### **Take the Challenge**
+
+Before you start, grab your timer. Start the clock and start cracking!
+[Register now](https://cloud.layer5.io/)

content/challenges/11111111-1111-1111-1111-111111111111/cncf-observability-challenge-with/distributed-tracing-with-jaeger/content/faq.md

@@ -0,0 +1,26 @@
+---
+docType: "Chapter"
+id: "FAQs"
+description: ""
+chapterTitle: "FAQs"
+title: "FAQs"
+weight: 3
+---
+
+#### Can I participate in a sample challenge?
+
+Yes, we recommend that you participate in our sample challenge.
+
+This challenge enables you to understand how to participate in challenges on Meshery. It comprises detailed information about how questions should be attempted and details about the Meshery judge.
+
+#### Do I need to register for the contest?
+
+Yes, in order to participate in a contest you do need to register for the contest with a Meshery account.
+
+#### How does the ranking work in a contest?
+
+Each problem has an assigned score. Usually a more challenging problem has a higher score. Your objective is to obtain the highest score with the fastest finish time while making as few mistakes as possible.
+
+#### Do I have to solve the contest problems in a particular order?
+
+No, you can solve the problems in any order you like. Feel free to read all of the problems at the beginning of contest. Looking at a problem does not affect your ranking.

content/challenges/11111111-1111-1111-1111-111111111111/cncf-observability-challenge-with/distributed-tracing-with-jaeger/content/getting-started.md

@@ -0,0 +1,30 @@
+---
+docType: "Chapter"
+id: "About Task"
+description: "This competition will challenge you to design an architecture diagram that demonstrates how Jaeger can be used to trace requests across a complex microservices architecture. You'll learn how to instrument your code, how to collect and analyze trace data, and how to visualize and interpret the results."
+chapterTitle: "About Task"
+title: "About Task"
+weight: 1
+---
+
+### **Eligibility Criteria**
+
+This challenge is open for all.
+
+### **The Rules**
+
+1. This contest is for individuals; teams are not allowed.
+2. Any competitor found cheating will be disqualified and banned from future contests.
+3. The architecture diagram must include the following components:
+    - Jaeger Agent
+    - Jaeger Collector
+    - Jaeger Query
+
+### **Scoring**
+Participants are ranked by score. Your score is determined by the number of test cases your code submission successfully passes. If two participants have the same score, the tie is broken by the contestant who took the least amount of time to solve the challenges.
+
+### **Can I participate in a sample challenge?**
+
+Yes, we recommend that you participate in our <a> sample challenge </a>.
+
+This challenge enables you to understand how to participate in challenges on Meshery. It comprises detailed information about how questions should be attempted and details about the Meshery judge.