From a1d9417a78a3e5130312e4f96d43eeb1afba0a64 Mon Sep 17 00:00:00 2001
From: Touriist <126756092+Touriist@users.noreply.github.com>
Date: Fri, 18 Oct 2024 19:05:50 +0000
Subject: [PATCH] add mastering meshery
Signed-off-by: Touriist <126756092+Touriist@users.noreply.github.com>
---
content-learn/mastering-meshery/index.mdx | 16 +
.../introduction-to-meshery/index.mdx | 24 ++
.../meshery/configuring-meshery.mdx | 227 +++++++++++
.../meshery/creating-designs.mdx | 192 ++++++++++
.../meshery/deploying-meshery-designs.mdx | 352 ++++++++++++++++++
.../meshery/interpreting-meshery-designs.mdx | 315 ++++++++++++++++
.../meshery/meshery-concepts.mdx | 60 +++
.../meshery/reviewing-designs.mdx | 245 ++++++++++++
8 files changed, 1431 insertions(+)
create mode 100644 content-learn/mastering-meshery/index.mdx
create mode 100644 content-learn/mastering-meshery/introduction-to-meshery/index.mdx
create mode 100644 content-learn/mastering-meshery/introduction-to-meshery/meshery/configuring-meshery.mdx
create mode 100644 content-learn/mastering-meshery/introduction-to-meshery/meshery/creating-designs.mdx
create mode 100644 content-learn/mastering-meshery/introduction-to-meshery/meshery/deploying-meshery-designs.mdx
create mode 100644 content-learn/mastering-meshery/introduction-to-meshery/meshery/interpreting-meshery-designs.mdx
create mode 100644 content-learn/mastering-meshery/introduction-to-meshery/meshery/meshery-concepts.mdx
create mode 100644 content-learn/mastering-meshery/introduction-to-meshery/meshery/reviewing-designs.mdx
diff --git a/content-learn/mastering-meshery/index.mdx b/content-learn/mastering-meshery/index.mdx
new file mode 100644
index 000000000000..a3e61f687b89
--- /dev/null
+++ b/content-learn/mastering-meshery/index.mdx
@@ -0,0 +1,16 @@
+---
+type: "learning-path"
+title: "Mastering Meshery"
+description: "Learn all about Meshery"
+order: 1
+themeColor: "#00D3A9"
+cardImage: "../../src/assets/images/learning-path/meshery-logo-light.webp"
+courses: 1
+technologyList: ["all"]
+prominentStyling: true
+---
+
+
diff --git a/content-learn/mastering-meshery/introduction-to-meshery/index.mdx b/content-learn/mastering-meshery/introduction-to-meshery/index.mdx
new file mode 100644
index 000000000000..b9ce50f35812
--- /dev/null
+++ b/content-learn/mastering-meshery/introduction-to-meshery/index.mdx
@@ -0,0 +1,24 @@
+---
+docType: "Course"
+title: "Course"
+description: "Explore Meshery comprehensively in this introductory course. Cover foundational concepts, architectural components, and logical structures. Learn how to create, deploy, and interpret designs. Gain practical insights into configuring Meshery through workspaces and leverage its collaborative attributes to manage your infrastructure."
+videos: 0
+lectures: 3
+courseTitle: "Introduction to Meshery"
+themeColor: "#00B39F"
+order: 1
+cardImage: "../../../src/assets/images/service-mesh-icons/linkerd-white.svg"
+toc:
+ [
+ "meshery-concepts",
+ "deploying-meshery-designs",
+ "configuring-meshery",
+ "creating-designs",
+ "interpreting-meshery-designs",
+ "reviewing-designs"
+ ]
+---
+
+
+Introduction to Meshery
+
diff --git a/content-learn/mastering-meshery/introduction-to-meshery/meshery/configuring-meshery.mdx b/content-learn/mastering-meshery/introduction-to-meshery/meshery/configuring-meshery.mdx
new file mode 100644
index 000000000000..091e2d6ebf89
--- /dev/null
+++ b/content-learn/mastering-meshery/introduction-to-meshery/meshery/configuring-meshery.mdx
@@ -0,0 +1,227 @@
+---
+docType: "Chapter"
+id: "configuring-meshery"
+chapterTitle: "Configuring Meshery"
+description: "This chapter covers the steps for configuring meshery, including the process of creating teams, workspaces, environments, and connections. It also explains how they associate with each other."
+videos: 0
+lectures: 4
+order: 1
+---
+import { ChapterStyle } from "../../../../src/components/Learn-Components/Chapters-Style/chapters.style.js";
+
+import lifecycleImage from "../../../../src/assets/images/learning-path/meshery-configure/lifecycle.png";
+import createTeamImage from "../../../../src/assets/images/learning-path/meshery-configure/create-team.png";
+import createWorkspaceImage from "../../../../src/assets/images/learning-path/meshery-configure/create-workspace.png";
+import confirmWorkspaceImage from "../../../../src/assets/images/learning-path/meshery-configure/confirm-workspace.png";
+import createEnvironmentImage from "../../../../src/assets/images/learning-path/meshery-configure/create-environment.png";
+import confirmEnvironmentImage from "../../../../src/assets/images/learning-path/meshery-configure/confirm-environment.png";
+import envArrowImage from "../../../../src/assets/images/learning-path/meshery-configure/env-arrow.png";
+import envConnectImage from "../../../../src/assets/images/learning-path/meshery-configure/env-connect.png";
+import mesheryEnvImage from "../../../../src/assets/images/learning-path/meshery-configure/meshery-env.png";
+import addClusterImage from "../../../../src/assets/images/learning-path/meshery-configure/add-cluster.png";
+import uploadKubeconfigImage from "../../../../src/assets/images/learning-path/meshery-configure/upload-kubeconfig.png";
+import invalidKubeconfigImage from "../../../../src/assets/images/learning-path/meshery-configure/invalid-kubeconfig.png";
+import connectionListImage from "../../../../src/assets/images/learning-path/meshery-configure/connection-list.png";
+import environmentsDesignsImage from "../../../../src/assets/images/learning-path/meshery-configure/environments-designs.png";
+import associateWithWorkspaceImage from "../../../../src/assets/images/learning-path/meshery-configure/associate-with-workspace.png";
+import confirmAssociatedWorkspaceImage from "../../../../src/assets/images/learning-path/meshery-configure/confirm-associated-workspace.png";
+
+
+
+
+Introduction
+
+Configuring Meshery is foundational to effectively managing and deploying your infrastructure. By understanding what `Teams`, `Workspaces`,`Connections` and `Environments` are and how to set them up, you can effectively manage and monitor your cloud-native infrastructure, as well as collaborate with your team by sharing and organizing your resources.
+
+**Prerequisite**
+
+1. Access to Meshery ([Self-Hosted](https://docs.meshery.io/installation) or [Meshery Playground](https://docs.meshery.io/installation/playground)).
+
+To start configuring Meshery:
+
+1. Navigate to the left sidebar of Meshery.
+1. Click on the **Lifecycle** dropdown and you will see all the menu items we need in this chapter.
+
+
+ 
+
+
+Creating Teams
+
+Creating a [Team](https://docs.layer5.io/cloud/identity/teams/) is the first step in configuring Meshery. In Meshery, a team is a user group that manages and shares access to resources such as Workspaces, Designs, and Environments. Teams enable efficient collaboration and permission management, facilitating organized operations within an organization. Teams offer control access to workspaces and to workspace resources such as Environments and Connections.
+
+Follow the steps below to create a team:
+
+1. Teams are visible when you visit the [**Identity**](https://meshery.layer5.io/identity/teams) page in Layer5 Cloud.
+1. Select **Add Team**, enter a name for your team, add Team Members, and **Create Team**.
+
+
+ 
+
+
+Creating Workspaces
+
+Creating a [Workspace](https://docs.layer5.io/cloud/spaces/workspaces/) is an important step in configuring Meshery. A workspace in Meshery is a logical grouping of resources that helps organize and manage your infrastructure more effectively. It is used to separate different projects or environments within your team, enabling better collaboration and resource management. Every user is assigned a default workspace, which can be customized as needed.
+
+To create a workspace:
+
+1. Navigate to **Workspaces** under the **Lifecycle** dropdown.
+
+1. Click **Create**.
+
+1. Enter a name for your workspace and **Save**.
+
+
+ 
+
+
+1. Once saved, the new Workspace will be created and displayed on the screen.
+
+
+ 
+
+
+In the subsequent sections, we will discuss `Environments` and `Designs` shown in the image above.
+
+Creating Environments and Associating Connections
+
+[Environments](https://docs.layer5.io/cloud/spaces/environments/) and [Connections](https://docs.meshery.io/concepts/logical/connections) are essential for efficient resource management in Workspaces. Environments logically group related Connections and Credentials, simplifying management and sharing. Connections within Environments become immediately available for use in any assigned Workspaces.
+
+Creating an Environment
+
+To create an environment:
+
+1. Navigate to **Environments** under the **Lifecycle** dropdown.
+
+1. Click **Create**.
+
+1. Enter the name of the environment and **Save**.
+
+
+ 
+
+
+1. Once saved, the new Environment will be created and displayed on the screen.
+
+
+ 
+
+
+Next We’ll learn how to assign Connections to Environments.
+
+Associating Connections with an Environment
+
+Examples of connections managed by Meshery include GitHub integrations, Prometheus connections, Kubernetes clusters, and more. It's essential to assign these connections to an environment and link that environment to your selected workspace.
+
+To add a connection to an environment:
+
+1. Click on the **arrows** icon, and a modal displaying your available connections will appear.
+
+
+ 
+
+
+1. **Available Connections** shows a list of Kubernetes clusters that are currently managed by Meshery.
+
+1. Select the connection(s) you want to assign.
+
+1. Use the appropriate arrow icons to manage your selections:
+ * The first arrow assigns all connections.
+ * The second arrow assigns only the selected connections.
+ * The third arrow removes the selected connection.
+ * The fourth arrow removes all connections.
+
+1. Click **Save** to confirm your changes.
+
+
+ 
+
+
+1. The Connections have now been assigned to the Environment.
+
+
+ 
+
+
+Navigating the Connections Page
+
+The `Connections` page serves as a central hub for managing the clusters you are connected to. This page provides valuable information and functionality to help you understand and interact with all your connections.
+
+To access the Connections page, click on **Connections** under the **Lifecycle** dropdown.
+
+Adding Cluster Connection
+
+On the Connections page, you can easily add a Kubernetes cluster connection. To do this:
+
+1. Click the **Add Cluster** button to get started.
+
+
+ 
+
+
+1. When the modal appears,navigate to the location of your kubeconfig file and upload it to add your cluster as a connection.
+
+
+ 
+
+
+1. After uploading the kubeconfig file, the modal should indicate that your cluster has been successfully added as a connection.
+
+ If you uploaded an invalid kubeconfig file, you might see an error message statement like the one below. Please ensure you are uploading the correct file with the proper configuration and try again.
+
+
+ 
+
+
+Viewing Cluster Connection Details
+
+Each connection has key details associated with it such as:
+
+1. **Environment**: This displays the environments associated with the connection. Click on the drop-down to add your connection to your Environment and see which Environments the connection is linked to.
+2. **Status**: Indicates the currently assigned state and information about what state the connection may or may not transition to. You can learn about [Connection Status](https://docs.meshery.io/concepts/logical/connections#states-and-the-lifecycle-of-connections)
+3. If [MeshSync](https://docs.meshery.io/concepts/architecture/meshsync) is actively running in your cluster, clicking the "Flush MeshSync" button will update MeshSync with the latest data, ensuring it matches the current state of your cluster.
+This ensures that MeshSync’s data is refreshed and accurately reflects the current state of your cluster’s infrastructure and resources.
+
+
+ 
+
+
+Integrating Workspaces with Environments and Designs
+
+You can assign your created Environments to Workspaces, enabling effective collaboration and resource utilization across your team. This feature allows you to organize your Environments based on specific projects, teams, or use cases, making it easier to manage and share resources within your organization.
+
+Integrating designs with Workspaces enables effective collaboration and sharing of infrastructure configurations across your team. When you assign an Environment containing your designs to a Workspace, team members with access to that Workspace can view, manage, and build upon the shared designs and share feedback.
+
+Assigning Environments and Designs to Workspaces
+
+1. Navigate to **Workspaces** under **Lifecycle**.
+
+1. In the image below, there are two **arrows** for associating `Environments` and `Designs` to Workspaces, respectively.
+
+
+ 
+
+
+1. Click the appropriate arrow to assign the selected Environments(or Designs) and **Save**.
+
+
+ 
+
+
+Confirm Workspace Association
+
+Now, the environment and design are associated with the workspace. You get standardized resource deployment and cross-team collaboration. This enables efficient resource management and tracking, and makes team members more productive.
+
+
+ 
+
+
+Conclusion
+
+In this chapter, you learned how to effectively configure Meshery, laying the groundwork for managing your infrastructure and optimizing workload within Kubernetes environments. Starting with the creation of workspaces, you established collaborative environments where teams can organize and deploy resources efficiently.
+
+You explored the setup of environments, which serve as logical groupings for managing Kubernetes connections and other resources. By adding cluster connections and associating them with environments, you ensured seamless integration and management of your infrastructure components.
+
+Throughout the configuration process, you encountered various steps to integrate workspaces with environments and designs. This integration not only streamlined resource management but also facilitated standardized deployments across Kubernetes clusters associated with your workspace.
+
+
diff --git a/content-learn/mastering-meshery/introduction-to-meshery/meshery/creating-designs.mdx b/content-learn/mastering-meshery/introduction-to-meshery/meshery/creating-designs.mdx
new file mode 100644
index 000000000000..b18c5ed32c1d
--- /dev/null
+++ b/content-learn/mastering-meshery/introduction-to-meshery/meshery/creating-designs.mdx
@@ -0,0 +1,192 @@
+---
+docType: "Chapter"
+id: "creating-designs"
+chapterTitle: "Creating Designs"
+description: "This chapter covers the essential steps for creating cloud-native designs in Kanvas. It explores how to start from scratch, import existing infrastructure files, and clone or merge designs from the Layer5 Cloud catalog. Additionally, it provides guidance on integrating GitHub for seamless version control and collaboration, allowing users to manage and configure their cloud-native deployments effectively."
+videos: 0
+lectures: 4
+order: 1
+---
+
+import exploreImage from "../../../../src/assets/images/learning-path/creating-designs/explore.png";
+import openKanvasImage from "../../../../src/assets/images/learning-path/creating-designs/open-kanvas.png";
+import step1Image from "../../../../src/assets/images/learning-path/creating-designs/step1.png";
+import step2Image from "../../../../src/assets/images/learning-path/creating-designs/step2.png";
+import step3Image from "../../../../src/assets/images/learning-path/creating-designs/step3.png";
+import step4Image from "../../../../src/assets/images/learning-path/creating-designs/step4.png";
+import step5Image from "../../../../src/assets/images/learning-path/creating-designs/step5.png";
+import importDesignImage from "../../../../src/assets/images/learning-path/creating-designs/import-design.png";
+import configuringImportedDesignImage from "../../../../src/assets/images/learning-path/creating-designs/configuring-imported-design.png";
+import mesheryHelmChartImage from "../../../../src/assets/images/learning-path/creating-designs/meshery-helm-chart.png";
+import cloneDesignImage from "../../../../src/assets/images/learning-path/creating-designs/clone-design.png";
+import listOfDesignsImage from "../../../../src/assets/images/learning-path/creating-designs/list-of-designs.png";
+import catalogImage from "../../../../src/assets/images/learning-path/creating-designs/catalog.png";
+import openInPlaygroundImage from "../../../../src/assets/images/learning-path/creating-designs/open-in-playground.png";
+import { ChapterStyle } from "../../../../src/components/Learn-Components/Chapters-Style/chapters.style.js";
+
+
+
+
+Introduction
+
+Creating designs in Kanvas is a seamless process that enables you to visualize, configure, and manage cloud-native infrastructure efficiently. This chapter will guide you through various methods of creating designs, whether starting from scratch, importing configuration files like Helm charts or Kubernetes manifests, or utilizing published designs from the Layer5 Cloud catalog.
+
+Accessing Designer Mode
+
+1. Log in to [Meshery Playground](https://meshery.layer5.io/). After successfully logging in, you'll land on the dashboard.
+
+2. In the Cloud Native Playground tile, click **Explore** to navigate to Kanvas.
+
+
+ 
+
+
+3. On the left sidebar, click the Kanvas icon to open Kanvas in Designer mode.
+
+
+ 
+
+
+Starting from Scratch
+
+Think of Designer mode as your blueprint studio. Just like architects use specific tools to design buildings, you use Kanvas to design your cloud-native applications.
+
+**Step 1: Create And Name Your Design**
+
+1. Click **New** at the top right of the screen to open a new design canvas.
+
+2. Give your design a meaningful name, reflecting its purpose or key components.
+
+
+ 
+
+
+**Step 2: Browsing Available Components**
+
+Explore the extensive Dock in **Designer** mode, which offers a wide range of Kubernetes and other integration components.
+
+Think of the Dock as a palette of building blocks for your cloud-native app. Just like selecting different materials for a construction project, you choose components for your app’s architecture.
+
+Components can be found in the **Dock** at the bottom of the design canvas.
+
+
+ 
+
+
+**Step 3: Selecting Specific Versions**
+
+To ensure precision in your design, select the specific version of each component you need. Kanvas supports a variety of versions for different components, allowing you to tailor your design to meet your exact requirements. A compatibility check is conducted, ensuring that selected versions align seamlessly within your design.
+
+Choosing component versions is similar to selecting software versions for your cloud-native app. It’s like picking the right versions of libraries to ensure your app functions smoothly.
+
+
+ 
+
+
+**Step 4: Building Complex Cloud Native Deployments**
+
+With the Designer toolbox at your disposal, effortlessly construct complex cloud-native deployments. Simply drag and drop components onto the Kanvas canvas, arranging and configuring them in a way that suits your architecture.
+
+
+ 
+
+
+**Step 5: Configuring Each Component**
+
+Configure your design by adjusting each component through the **Configuration** tab. Click on the component to open up its Configuration tab. Kanvas's intuitive interface allows you to enter settings and parameters directly on the design canvas. As you modify these configurations, your design updates in real-time. Kanvas's auto-sync feature ensures that configuration changes are instantly reflected in the design.
+
+
+ 
+
+
+**Step 6: Design Actions and Interactions**
+
+Explore additional design actions by right-clicking on components. Group components together or establish connections between them according to your needs. Kanvas responds in real-time to design actions, providing a fluid and responsive user experience.
+
+Starting from existing infrastructure files
+
+When working with Kanvas, you can effortlessly integrate various design files to start building and managing your cloud-native applications. Whether you’re working with Helm charts, Docker Compose files, or Kubernetes manifests, Kanvas provides a unified interface to import these files and visualize your infrastructure setup. This versatility allows you to streamline the design process, ensure consistency, and tailor your cloud-native environments to meet specific needs.
+
+**Importing a Design**
+
+1. Click the **Import design** option under the **Designs** tab in Kanvas.
+
+
+ 
+
+
+2. Enter a name for the design in the **Design File Name** field.
+
+3. Choose the appropriate **Design Type** for the file you want to import (Helm Chart, Kubernetes, Manifest, etc).
+
+4. Select your preferred import method: either **URL** or **File Upload**.
+
+
+ 
+
+
+5. **Example:** Use the Meshery Server Helm chart at [Meshery Helm Chart](https://meshery.github.io/meshery.io/charts/meshery-v0.7.48.tgz).
+
+
+ 
+
+
+6. **Review and Modify:** You should now have a Kanvas design of the chart. Continue to make any changes if required or deploy it.
+
+Cloning a Design
+
+**Steps to Clone a Design from Catalog using Kanvas:**
+
+1. Switch to Kanvas Designer mode, if not already in it.
+
+2. In the left navigation panel, click the **“Catalog”** menu tab.
+
+3. Select a design from the list that appears in the panel.
+
+4. A modal will pop up requesting you to clone (create a copy of) the design you’ve selected.
+
+
+ 
+
+
+5. Click **“clone”** and a copy of the design will appear on your Kanvas canvas. You can then configure the design to suit your purposes.
+
+6. Find your newly cloned design in the list of designs in the left navigation panel.
+
+
+ 
+
+
+Github Integrations
+
+Integrating your GitHub account with Meshery unlocks the ability to import files as designs directly from your repositories, enhancing your collaboration and version control processes. This integration allows you to streamline your workflow, ensuring that your design infrastructure is always up-to-date and aligned with your source code. To get started with integrating GitHub into Meshery, follow the comprehensive guide available [here](https://docs.layer5.io/cloud/getting-started/github-integration/).
+
+After importing your designs, they will appear in the [catalog](https://meshery.layer5.io/catalog).
+
+
+ 
+
+
+To view the design on the canvas:
+
+1. Click on the Catalog Card.
+
+2. Click on **Open in Playground**. This will display the design on the canvas.
+
+
+ 
+
+
+Merging Designs
+
+For enhanced collaboration and scalability, merge existing designs into your canvas by dragging and dropping. This feature enables you to consolidate multiple designs, creating a unified and comprehensive view of your infrastructure.
+
+Kanvas orchestrates the merging process internally, creating a unified design that incorporates components from the dragged designs. Importantly, users do not lose their original designs during the merging process. Kanvas retains records of each design, preserving their individuality. To learn how to merge designs, see [Merging Designs](https://docs.meshery.io/extensions/merging-design).
+
+Conclusion
+
+In this chapter, we explored the comprehensive process of creating cloud-native designs using Kanvas. We covered how to start a design from scratch by naming, configuring, and arranging components in Designer mode. We also demonstrated how to import existing infrastructure files, such as Helm charts or Kubernetes manifests, directly into your design canvas for efficient deployment and management.
+
+Additionally, we learned how to clone existing designs from the Layer5 Cloud catalog and integrate them into our workspace. The chapter also delved into the integration of GitHub, allowing seamless import of design files from your repositories, enabling better collaboration and version control.
+
+
\ No newline at end of file
diff --git a/content-learn/mastering-meshery/introduction-to-meshery/meshery/deploying-meshery-designs.mdx b/content-learn/mastering-meshery/introduction-to-meshery/meshery/deploying-meshery-designs.mdx
new file mode 100644
index 000000000000..65344d0a824d
--- /dev/null
+++ b/content-learn/mastering-meshery/introduction-to-meshery/meshery/deploying-meshery-designs.mdx
@@ -0,0 +1,352 @@
+---
+docType: "Chapter"
+id: "deploying-meshery-designs"
+chapterTitle: "Deploying Meshery Designs"
+description: "This chapter covers the steps for deploying Meshery Designs, including validation, dry-run, environment selection, and deployment. It explains how to carry out these actions, addresses possible errors, and provides remediation strategies. Additionally, it covers how to use the Notification Center for troubleshooting errors and viewing the deployment status."
+videos: 0
+lectures: 4
+order: 1
+---
+import { ChapterStyle } from "../../../../src/components/Learn-Components/Chapters-Style/chapters.style.js";
+import performingValidation from "../../../../src/assets/images/learning-path/meshery-deploy/performing-validation.png";
+import successfulValidation from "../../../../src/assets/images/learning-path/meshery-deploy/successful-validation.png";
+import validationError from "../../../../src/assets/images/learning-path/meshery-deploy/validation-error.png";
+import successfulDryRun from "../../../../src/assets/images/learning-path/meshery-deploy/successful-dry-run.png";
+import drInvalidField1 from "../../../../src/assets/images/learning-path/meshery-deploy/dr-invalid-field1.png";
+import drInvalidField2 from "../../../../src/assets/images/learning-path/meshery-deploy/dr-invalid-field2.png";
+import missingField from "../../../../src/assets/images/learning-path/meshery-deploy/missing-field.png";
+import missingResource from "../../../../src/assets/images/learning-path/meshery-deploy/missing-resource.png";
+import addEnv from "../../../../src/assets/images/learning-path/meshery-deploy/add-env.png";
+import createEnv from "../../../../src/assets/images/learning-path/meshery-deploy/create-env.png";
+import assignConn from "../../../../src/assets/images/learning-path/meshery-deploy/assign-conn.png";
+import kubeConn from "../../../../src/assets/images/learning-path/meshery-deploy/kube-conn.png";
+import missingCon from "../../../../src/assets/images/learning-path/meshery-deploy/missing-con.png";
+import envConn from "../../../../src/assets/images/learning-path/meshery-deploy/env-conn.png";
+import connList from "../../../../src/assets/images/learning-path/meshery-deploy/conn-list.png";
+import envError from "../../../../src/assets/images/learning-path/meshery-deploy/env-error.png";
+import successDeploy from "../../../../src/assets/images/learning-path/meshery-deploy/success-deploy.png";
+import missingNs from "../../../../src/assets/images/learning-path/meshery-deploy/missing-ns.png";
+import emptyLs from "../../../../src/assets/images/learning-path/meshery-deploy/empty-ls.png";
+import errorCode from "../../../../src/assets/images/learning-path/meshery-deploy/error-code.png";
+import notification from "../../../../src/assets/images/learning-path/meshery-deploy/notification.png";
+import notificationCenter from "../../../../src/assets/images/learning-path/meshery-deploy/notification-center.png";
+import undeploy from "../../../../src/assets/images/learning-path/meshery-deploy/undeploy.png";
+import action from "../../../../src/assets/images/learning-path/meshery-deploy/action.png";
+
+
+
+
+Introduction
+
+Deploying Meshery designs is a common and essential task for managing your infrastructure and workloads. Having a thorough understanding of this procedure and Meshery’s design deployment behavior is key to ensuring that your component configurations work as intended in a live Kubernetes environment. Meshery’s design deployment process not only attests to the validity of your configuration, but also offers a seamless transition from Designer mode to Visualizer mode, where you can visually inspect your deployment, and begin to manage live-running deployments in your environment.
+
+Meshery’s deployment process encompasses four steps: validation, dry-run, environment selection, and finally, executing the deployment itself.
+
+This chapter guides you through each of these four steps. Along the way, you will learn what a successful step looks like, understand common failure scenarios, and go through strategies for troubleshooting and resolving any issues that might arise. Additionally, you will learn about Meshery’s [Notification Center](https://docs.meshery.io/guides/infrastructure-management/notification-management) and how to best use it to your advantage.
+
+**Prerequisites**
+
+1. Ensure you have one or more Meshery designs available.
+
+1. Access to Meshery ([Self-Hosted](https://docs.meshery.io/installation) or [Meshery Playground](https://docs.meshery.io/installation/playground)).
+
+Action Button
+
+There are two modes on the Actions button:
+
+1. Clicking on the word **Actions** presents a set of choices, each labeled with its respective action. Selecting an option opens a modal window, providing detailed guidance.
+
+1. Clicking on the Action drop-down icon reveals a list of icons. Selecting an icon allows seasoned users to perform actions with a single click, bypassing the modal interaction.
+
+In this chapter, we focus on utilizing the first option to provide a comprehensive view of the deployment process.
+
+
+ 
+
+
+Design Validation
+
+Validation is the first step in deploying designs with Meshery. While optional, it is highly recommended as it helps identify and resolve possible misconfigurations upfront.
+
+How Validation Works
+
+Meshery uses static analysis to verify your design. It checks all components within your design and all configured and unconfigured properties of your components against well-defined schemas based on [Meshery Models](https://docs.meshery.io/concepts/logical/models).
+
+This comprehensive validation ensures that:
+
+1. The design adheres to the expected structure and format.
+1. All components are valid and recognized by Meshery.
+1. There are no missing required configurations.
+
+Performing Validation
+
+1. To validate your design, navigate to the Actions button at the top of the Design canvas.
+
+1. Click on the **Validate** Icon.
+
+
+ 
+
+
+ If the validation is successful, you will see a modal displaying the number of components validated and the number of annotations, similar to the one shown below:
+
+ {" "}
+
+
+ 
+
+
+Handling Validation Errors
+
+If your design fails validation checks, the modal will indicate the number of errors detected. Each error will provide specific information about the component or annotation that caused the failure. Use this detailed feedback to identify and correct the issues in your design before proceeding with the deployment.
+
+Validation Errors
+
+A common validation error is:
+
+1. **Missing Required Field**: This happens when a required field is not provided. For example, in the image below, the first error indicates that the field ".spec.template.spec.containers.0.env.0" must have a value.
+
+
+ 
+
+
+To troubleshoot and remediate validation issues:
+
+1. Click on the error on the modal.
+1. This will open the configuration tab of the component that has that error.
+1. Fix the configuration using the error details provided.
+1. Re-run validation after any significant changes to your design to ensure all issues are resolved.
+
+The validation process is confined to schema-based checks within Meshery and does not require communication with your target environment. The Dry Run step, however, does involve this communication. Let’s explore the Dry Run step next.
+
+Design Dry Run
+
+A dry run in Meshery simulates the deployment of your design in the selected target environment _without_ making any actual changes. This step is highly beneficial as it helps identify potential issues before they occur, ensuring a smoother and more reliable deployment process.
+
+Performing Dry Run
+
+1. Navigate to the **Actions** button at the top of the Design canvas.
+1. Click on the **Dry Run** icon.
+1. Review the results to identify any potential issues.
+1. Make necessary adjustments to your configuration based on the feedback provided by the dry run.
+1. Re-run the dry run to ensure all issues have been resolved.
+
+
+ 
+
+
+Examples of Dry Run Errors
+
+Some examples of dry run errors are:
+
+1. **Invalid Field Value**: The error message indicates that a field has an invalid value. For instance, in the image below, the fields "spec > ports[0] > port" and "spec > ports[0] > targetPort" have invalid values of 0. These values must be between 1 and 65535, inclusive.
+
+
+ 
+
+
+
+ 
+
+
+1. **Missing Required Field**
+
+
+ 
+
+
+1. **Missing Dependencies**: In this case, the error occurs because a Kubernetes [Custom Resource Definition](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/) (CRD) should have been deployed first before attempting to deploy this component.
+
+ To resolve this, ensure that all necessary dependencies, such as CRDs, are deployed before deploying the components that rely on them.
+
+
+ 
+
+
+Environment Selection
+
+[Meshery Environments](https://docs.layer5.io/cloud/spaces/environments) are logical groups of [Connections](https://docs.meshery.io/concepts/logical/connections) which include GitHub integrations, Prometheus connections, and Kubernetes Clusters and so on managed by Meshery. To make your Kubernetes connections available for selection, you need to assign them to an environment and link that environment to your current [workspace](https://docs.layer5.io/cloud/spaces/workspaces). _Note: Environments can be assigned to one or more Workspaces._
+
+Adding an Environment During Deployment
+
+During deployment, you will be required to select an environment.
+
+You can add an environment through the deployment modal by following these steps:
+
+1. Click on **Add Environments**
+
+
+ 
+
+
+1. Select **Create** and put in a name for the environment, _e.g.Development_, and **Save**.
+
+
+ 
+
+
+1. After creating the environment you add connections to the environment, here we want to add a Kubernetes cluster. Click on the **arrows** icon to open the Development Resources modal.
+
+
+ 
+
+
+ **Available Connections** on the left side shows a list of Kubernetes clusters that are currently managed by Meshery.
+
+
+ 
+
+
+
+**_Add Kubernetes Connections:_** If you do not have any **Kubernetes connections** available, refer to this documentation on how to manage your clusters with Meshery: [Managing Kubernetes Clusters with Meshery](https://docs.meshery.io/installation/kubernetes).
+
+1. Select a cluster, and use the arrow to assign just the selected connections and save.
+
+Missing Connections
+
+During the deployment, if a connection has not yet been added to your environment, it will appear as shown below.
+
+
+ 
+
+
+In this scenario, to add a new environment.
+
+1. Navigate to the left sidebar of Meshery
+1. Click on the **Lifecycle** dropdown and you will see the **Environment** Icon under it
+1. Click on it and you can follow the same steps we mentioned above to add a connection to your environment.
+
+Selecting an Environment for an Existing Connection
+
+Another way to add a connection to an Environment is by selecting an environment for an existing connection. To do this:
+
+1. Click on the **Lifecycle** icon to view a list of connections with their attributes, including environments, kind (type of connection), and connection status.
+
+1. Identify the desired connection. Under the **Environment** section, click the dropdown menu to add and select the environment you want to associate with your connection.
+
+
+ 
+
+
+Verifying Kubernetes Connections
+
+The Kubernetes connection icon at the top right corner of the screen shows the list of connected Kubernetes clusters.
+Clicking on the icon will invoke an ad hoc connectivity test between your Meshery Server and the specific Kubernetes cluster. Should this check fail, verify the health of your Meshery Operator deployment within that cluster.
+
+
+ 
+
+
+Environment Error
+
+If your environment is not properly set up before deployment, you may encounter the error below.
+
+
+ 
+
+
+To handle this error follow the suitable steps for adding a connection to your environment as previously discussed.
+
+Deployment
+
+At this stage, you deploy your resources to your available Kubernetes cluster connection(s) managed by Meshery.
+First, ensure the connections to your clusters are established and configured correctly, placing them in the appropriate environments. This ensures you have control over your deployment strategy.
+
+Kubernetes Cluster Management using Meshery
+
+Meshery Server [deploys](https://docs.meshery.io/installation) as a single container. Whether the Meshery Server container is deployed in a stand-alone Docker host or inside a Kubernetes cluster, Meshery Server is fully capable of **managing multiple Kubernetes clusters**. For more information on how Meshery Server connects to and continually synchronizes with your Kubernetes cluster(s), see [Meshery Operator](https://docs.meshery.io/concepts/architecture/operator) and [MeshSync](https://docs.meshery.io/concepts/architecture/meshsync).
+
+Understanding Meshery Operator and Kubernetes Cluster Relationships
+ **One-to-One Relationship**: There is a one-to-one relationship between a Meshery Operator and a Kubernetes cluster. This means each Meshery Operator is associated with exactly one Kubernetes cluster. This applies whether the cluster is a managed cluster (like the one you’re adding as a connection) or the cluster where the Meshery Server is deployed.
+
+ **Many-to-One Relationship**: There is a many-to-one relationship between Meshery Operator and Meshery Server. Multiple Meshery Operators can be associated with a single Meshery Server. This means a single Meshery Server can manage several Kubernetes clusters through different Meshery Operators.
+
+In summary, while each Kubernetes cluster has its own Meshery Operator, a single Meshery Server can interact with multiple Kubernetes clusters through these Operators.
+
+Available Clusters
+
+**_Playground Users:_** Users of Meshery Playground should see a pre-registered Kubernetes connection, representing the sandbox cluster available with the playground environment.
+
+You have the option of using the live cluster provided by Meshery Playground or connecting your own Kubernetes cluster using your kubeconfig file. During deployment, these clusters will be available as connections for you to select.
+
+Deploying Designs
+
+1. To deploy a design, navigate to the Actions button at the top of the Design canvas.
+1. Click on the **Deploy** icon.
+1. This opens a modal that will take you through all the steps before the final deployment.
+1. Click on **Open In Visualizer** to see the pre-filtered view of the deployed resources in the cluster.
+1. Click **Finish**.
+
+
+ 
+
+
+Deployment Errors
+
+1. **Missing Namespace**: This error occurs when you attempt to create a Kubernetes resource without specifying a namespace. Kubernetes requires that all resources have an associated namespace.
+
+
+ 
+
+
+1. **Empty Label Selector**: This error indicates an empty label selector.
+
+
+ 
+
+
+Troubleshooting Errors
+
+When reviewing validation, dry run, or deployment issues, you’ll notice specific error codes denoted from time to time.
+
+As a system, Meshery itemizes different errors that occur and assigns a unique error code to each along with details on how to remediate the issue at hand.
+
+For the comprehensive list of error codes refer to [Error Code Reference](https://docs.meshery.io/reference/error-codes) in the Meshery documentation.
+
+If you encounter persistent issues, consider consulting the [Meshery Community forum](https://discuss.layer5.io/c/meshery/5).
+
+
+ 
+
+
+Using the Notification Center for Troubleshooting
+
+The Notification Center in Meshery helps manage events during the deployment process. It provides real-time updates and alerts on the status of the deployment. This feature can be particularly useful for troubleshooting, as it:
+
+1. Displays immediate feedback on the success or failure of each deployment step.
+
+1. Highlights specific error messages and codes, helping you quickly identify and understand issues.
+
+1. Offers links to detailed documentation and guides for resolving common problems.
+
+1. Keeps a log of past notifications, allowing you to track and review previous errors and their resolutions.
+
+
+ 
+
+
+
+ 
+
+
+By actively monitoring the Notification Center, you can promptly address issues as they arise, ensuring a smoother deployment process. Learn more about [Managing Events with the Notification Center](https://docs.meshery.io/guides/events-management).
+
+Undeploy
+
+To undeploy the resources
+
+1. Navigate to the Actions button at the top of the Meshery Design canvas.
+1. Click on the **Undeploy** icon.
+
+
+ 
+
+
+
+Conclusion
+
+In this chapter, you learned how to effectively deploy Meshery designs, ensuring your resources are deployed in the correct environment. You started by validating your designs to ensure configurations adhere to Kubernetes API specifications and best practices. Next, you did a dry run to simulate deployments without making actual changes. You also explored how to select and configure environments to manage Kubernetes connections seamlessly, and finally, how to deploy resources to your preferred cluster.
+
+Throughout these steps, you encountered common errors and learned how to address them. During these steps, you learned how to use Meshery's Notification Center to troubleshoot issues, helping you through the deployment process.
+
+
\ No newline at end of file
diff --git a/content-learn/mastering-meshery/introduction-to-meshery/meshery/interpreting-meshery-designs.mdx b/content-learn/mastering-meshery/introduction-to-meshery/meshery/interpreting-meshery-designs.mdx
new file mode 100644
index 000000000000..dae91d604bae
--- /dev/null
+++ b/content-learn/mastering-meshery/introduction-to-meshery/meshery/interpreting-meshery-designs.mdx
@@ -0,0 +1,315 @@
+---
+docType: "Chapter"
+id: "interpreting-meshery-designs"
+chapterTitle: "Interpreting Meshery Designs"
+description: "This chapter delves into the process of understanding the visually expressive language of Meshery designs."
+videos: 0
+lectures: 4
+order: 1
+---
+import * as React from "react";
+import MesheryDesignEmbed from "@layer5/meshery-design-embed";
+import { ChapterStyle } from "../../../../src/components/Learn-Components/Chapters-Style/chapters.style.js";
+import CreateAnnotationGif from "../../../../src/assets/images/learning-path/interpreting-designs/create-annotation.gif";
+import AnnotationExampleGif from "../../../../src/assets/images/learning-path/interpreting-designs/annotations-examples.png";
+import EdgeNetworkGif from "../../../../src/assets/images/learning-path/interpreting-designs/edge-network-relationship.gif"
+import CustomizeKubernetesGif from "../../../../src/assets/images/learning-path/interpreting-designs/customize-kubernetes.gif";
+import basicDesign from "../../../../src/assets/images/learning-path/interpreting-designs/basic-meshery-design.png";
+import edgePermissionGif from "../../../../src/assets/images/learning-path/interpreting-designs/edge-permission.gif";
+import Triangles from "../../../../src/assets/images/learning-path/interpreting-designs/triangles.svg";
+import Rectangles from "../../../../src/assets/images/learning-path/interpreting-designs/rectangles.svg";
+import Users from "../../../../src/assets/images/learning-path/interpreting-designs/users.svg";
+import Cylinders from "../../../../src/assets/images/learning-path/interpreting-designs/cylinders.svg";
+import DashedArrows from "../../../../src/assets/images/learning-path/interpreting-designs/dashed_arrow.svg";
+import AnnotationArrow from "../../../../src/assets/images/learning-path/interpreting-designs/annotation-arrow.svg";
+import NetworkEdgeRelationship from "../../../../src/assets/images/learning-path/interpreting-designs/network_edge_relationship.svg";
+import EdgePermissions from "../../../../src/assets/images/learning-path/interpreting-designs/edge_permission.svg";
+import Integrations from "../../../../src/assets/images/learning-path/interpreting-designs/integrations.svg";
+
+
+
+Introduction
+
+Meshery [Designs](https://docs.meshery.io/concepts/logical/designs) provide a visual blueprint for your infrastructure, showcasing the various components and their relationships. These designs can encompass Kubernetes resources and their relationships, annotations, and the numerous cloud-native and application integrations that Meshery supports.
+
+In this guide, you will learn how to identify these components and gain a clear understanding of their significance within the design.
+
+Meshery Designs and Models
+
+Meshery Designs leverage the power and flexibility of Meshery Models as their foundation.
+
+Meshery [Models](https://docs.meshery.io/concepts/logical/models) are standardized packages that bundle **components** and characterize their **relationships**. Models provide a structured, reusable, and extensible way to represent infrastructure components and their relationships, going beyond just code. This enables a more flexible and adaptable approach to modeling complex systems.
+
+Understanding Meshery Components
+
+A Meshery component is a unit within a Meshery model, essentially representing and defining specific infrastructure elements or resources. They represent and configure specific resources, like network setups, service configurations, and deployment details.
+
+For example:
+
+- A `Kubernetes` model will have components that represent resources such as `Deployments`, `Services`, `ConfigMaps` etc
+- Similarly, an `AWS EC2` model includes components such as `NAT Gateway`, `Route Table` and `Subnet`.
+
+These components encapsulate the resources and include their detailed configurations and interaction rules within the larger infrastructure. Not only do they serve as blueprints, but they can also be integrated and deployed to your cluster using Meshery, transforming your designs into reality!
+
+
+Meshery Design at a Glance
+
+
+ 
+
+
+
+The design above shows a simple Meshery Design that consists of Kubernetes components. It specifically illustrates some kubernetes resources that are required to deploy an application to a Kubernetes cluster.
+
+In the Meshery Design, you can see various Kubernetes components that make up this infrastructure, including `services`, `deployments`, and `custom resources`. The relationships between these components are also clearly depicted through arrows.
+
+Meshery Component Representation
+
+Components are represented by various shapes and icons that effectively illustrate their roles in the infrastructure. These icons are designed to intuitively convey their functions, making them easy to identify. Users also have the flexibility to customize these icons to suit their preferences, enabling a more personalized design experience.
+
+Major Meshery components that can be found in a design include:
+
+1. **Kubernetes Components**: Resources like `Deployments`, `Services`, and `ConfigMaps`.
+1. **Meshery Integration Components**: Configurable components that can be deployed to a cluster, representing integrations with various applications and cloud native infrastructure.
+For example, resources such as `Subnet`, `VPC`, and `NAT Gateway` are specific to the AWS integration with Meshery.
+
+First let's take a look at the Kubernetes Components.
+
+Kubernetes Components
+
+Kubernetes components are represented by `blue icons`, distinguishing them from other component types. These icons and shapes visually signify the roles and functions of each Kubernetes component within your infrastructure.
+
+As you familiarize yourself with Meshery Designs, you'll quickly recognize the unique icons and shapes representing these Kubernetes components.
+
+
+Basic Concepts of Kubernetes Components in Meshery
+
+Some Kubernetes components can be categorized by their distinct shapes and icons, which help distinguish them based on their roles within the system.
+
+This makes it intuitive to identify each component’s function, enhancing the user experience when designing and interpreting infrastructure blueprints.
+
+Let's explore a few of these categories.
+
+1. **Triangles**:
+
+ 
+
+ - **Category**: **Networking and Service Management**.
+
+ - **Description**: Triangular shapes are used for components that manage or interact with networking and service-related functions. This includes defining how services are exposed and connected within the cluster.
+
+ - **Examples**: API Service, Service.
+
+
+1. **Rectangles**:
+
+ 
+
+ - **Category**: **Hierarchical and Parent Components**
+
+ - **Description**: In Meshery, hierarchical or parent components are represented as transparent squares, which signify their capacity to contain or organize other resources within the cluster.
+
+ As elements are added, these squares expand into rectangles, visually reinforcing their role in managing and structuring resources. The transparency of these shapes highlights their function as parent components, differentiating them from other types of Kubernetes resources.
+
+ - **Examples**: Namespace, Node, Pod, ReplicaSet, DaemonSet, Horizontal Pod Autoscaler.
+
+1. **User Icons**:
+
+ 
+
+ - **Category**: **Role-based access control (RBAC) components**
+
+ - **Description**: These components are related to user permissions and access management in Kubernetes.
+
+ - **Examples**: ClusterRole, Role, Service Account etc.
+
+1. **Cylinders**:
+
+ 
+
+ - **Category**: **Storage and Stateful Components**
+
+ - **Description**: In Meshery, cylindrical shapes are used to represent components associated with storage and state management in Kubernetes. These shapes symbolize persistent storage and resources that manage or interact with storage systems.
+
+ - **Examples**: CSI Node, CSI Driver, CSI Storage Capacity, Persistent Volume, Persistent Volume Claim (PVC), StatefulSet, Volume Attachment, Storage Class.
+
+**_Component Shape Guide:_** To learn more about the usage of shapes and why specific shapes were chosen for Kubernetes resources, see the [Component Shape Guide](https://docs.meshery.io/extensions/component-shape-guide).
+
+**_Kubernetes Components Categories:_** These categories also serve as a guide for users customizing Kubernetes components. By using these established shapes and icons as a reference, you can ensure that your customizations maintain semantic meaning and align with the existing representations, helping to preserve clarity and consistency in your designs.
+
+
+Arrows in Meshery Designs
+
+Arrows in Meshery designs visually represent relationships between components. Meshery uses two primary arrow styles: one for **edge relationships** and another for **annotations**. These styles come with default meanings assigned by Meshery, providing a clear visual language for understanding component interactions.
+
+Note that users have the flexibility to **customize** these arrow styles to suit their design preferences.
+
+**Edge Relationships**
+
+
+
+These are used to indicate traffic flow and relationships between components. The dashed lines represent dynamic interactions and data movement, while the arrowheads show the direction of the flow or relationship.
+
+**Annotations**
+
+
+
+These are used to denote annotations or static connections between components. They serve to illustrate fixed relationships or highlight specific details without implying a flow of data or interaction.
+
+Examples of Edge Relationships
+
+1. **Edge-Network Relationship**: Represented by a dashed arrow with **port/network protocol**.
+
+
+
+- **Dashed arrow**: Indicates that the service is linked to the pod, exposing network access to it through a specified port.
+- **Port/Network Protocol**: Indicates the Port exposed by the service and its corresponding network protocol.
+
+**Creating Edge-Network Relationships Between Kubernetes Components**
+
+
+ 
+
+
+
+1. **Edge-Permission Relationships**: Represented by a dashed arrow with an intermediary component, this type of edge indicates a binding relationship between two components.
+
+The intermediary component (such as a RoleBinding) connects the two, defining how permissions are assigned. For example, a dashed arrow from a `Role` to a `ServiceAccount` with a `RoleBinding` in the middle shows the connection established by the RoleBinding, which links the specific role to the service account and grants the appropriate permissions.
+
+
+
+**Creating Edge-Permission Relationships Between Components**
+
+
+ 
+
+
+
+To see more examples on Edge relationships, See [Relationships](https://docs.meshery.io/concepts/logical/relationships).
+
+
+Meshery Integration Components
+
+Meshery extends and offers support for numerous [integrations](https://docs.meshery.io/extensibility/integrations) with Cloud native infrastructure and applications.
+
+In Meshery, these integrated components are distinctly represented by their specific logos as icons and various shapes. These components can be found in `Components` in the dock.
+
+
+_Example of integration components in Meshery_
+
+Below is a Meshery Design with AWS Components.
+
+
+
+Methods to Identify Components on the Playground Design Canvas
+
+1. **Search on the Dock**: Start by navigating to the Dock at the bottom of the design canvas. To locate Kubernetes components, click on the Kubernetes icon. You can then either search directly for the resource name you are interested in or scroll through to find it.
+
+1. **Configuration Tab**: Click on a component within the design, and a configuration tab will open. The name of the component will appear at the top of this tab.
+
+Annotations
+
+In a Meshery design, annotations can take various forms, such as labels, arrows, sections used to group components, or non-configurable components like plain shapes, AWS icons, GCP icons, and flowchart shapes.
+
+These annotations are used solely for design purposes within Meshery. While these annotations are not deployable or functional components, they serve to enhance the design by providing additional context and illustrating connections between components.
+
+Annotations can be created using Meshery's Diagramming tools found in the dock at the bottom of the design canvas.
+
+Annotation Examples
+
+1. **Descriptions/labels**: This gives details on components. Can be created using the `Textbox` in the dock.
+1. **Arrows**: These are used to show relationships between components.
+
+1. **Sections**: This can be used to visually group components into sections to have a better understanding of your infrastructure. This is created using `Sections` in the dock.
+
+1. **Shapes**: These include the plain shapes, AWS icons, GCP icons, and flowchart shapes. They can be founf in `Shapes` in the dock. These are non-configurable and are used solely for design purposes.
+
+1. **Images**: Images can be added to the design to represent components, logos, or any visual aid that supports understanding the architecture.
+
+
+ 
+
+
+
+The design below includes annotations such as sections, images, arrows, and various shapes.
+
+
+
+
+Customizing Components and Annotation
+
+While default shapes, colors, and icons are provided for components and annotations, you have the flexibility to customize these components to better suit your design needs.
+
+**Customizing Kubernetes Components**
+
+
+ 
+
+
+
+**Creating and Customizing Arrow Annotations**
+
+
+ 
+
+
+
+**_Edge Style Guide:_** To learn more about the available arrow edge styles, See Edge Sytle Guide(https://docs.meshery.io/extensions/edges-shape-guide).
+
+Every other Component and Annotation that has been discussed can be customized using the method shown above.
+
+Conclusion
+
+In this guide, you’ve explored the diverse components within Meshery designs and learned to interpret their various meanings. You’ve gained insights into identifying Kubernetes components and other integrations supported by Meshery, understanding their unique roles and functions.
+
+We’ve also covered how to differentiate between functional components, their relationships, and annotations within your designs. By recognizing these elements and their visual representations, you can better understand and manage your Meshery designs. This knowledge will enable you to create more effective and insightful designs, enhancing your ability to visualize and manage complex systems.
+
+
\ No newline at end of file
diff --git a/content-learn/mastering-meshery/introduction-to-meshery/meshery/meshery-concepts.mdx b/content-learn/mastering-meshery/introduction-to-meshery/meshery/meshery-concepts.mdx
new file mode 100644
index 000000000000..f5d354dbb6d4
--- /dev/null
+++ b/content-learn/mastering-meshery/introduction-to-meshery/meshery/meshery-concepts.mdx
@@ -0,0 +1,60 @@
+---
+docType: "Chapter"
+id: "meshery-concepts"
+chapterTitle: "Meshery Concepts"
+description: "This chapter delves into the fundamental concepts of Meshery, explaining its purpose, and the architectural and logical components that form its foundation."
+videos: 0
+lectures: 4
+order: 1
+---
+
+import { ChapterStyle } from "../../../../src/components/Learn-Components/Chapters-Style/chapters.style.js";
+
+
+
+
+What is Meshery?
+
+Meshery is a self-service engineering platform that enables collaborative design and operation of cloud and cloud-native infrastructure. It's a versatile tool designed to help engineers manage and operate their infrastructure visually, collaboratively, and confidently. Whether you are a platform engineer, a site reliability engineer, or part of a DevSecOps team, Meshery has something to offer.
+
+Meshery’s Purpose
+
+Meshery's primary purpose is to facilitate the collaborative design, operation, and management of cloud and cloud-native infrastructure. By providing a unified platform that integrates with various tools and technologies, Meshery aims to streamline infrastructure management tasks for engineers. Its goals include:
+
+1. **Enhancing Collaboration:** Meshery allows teams of engineers to work together more effectively by providing a visual and intuitive interface for managing infrastructure.
+2. **Simplifying Complexity:** It abstracts the complexity of managing multiple Kubernetes clusters and cloud-native environments, making it easier for engineers to deploy, monitor, and manage applications.
+3. **Ensuring Extensibility:** As an open-source project, Meshery is highly extensible, allowing users to customize and extend its functionality to meet their specific needs.
+4. **Improving Performance Management:** Meshery provides tools for performance analysis, helping teams understand and optimize the performance of their applications and infrastructure.
+5. **Promoting Best Practices:** Through its various features and capabilities, Meshery encourages the adoption of best practices in cloud-native infrastructure management, such as using standardized designs and patterns.
+
+Meshery is designed to be a versatile and powerful tool that addresses the modern needs of infrastructure management in cloud-native environments, making it easier for engineers to manage their infrastructure with confidence and efficiency.
+
+Architectural Components
+
+Architectural components in Meshery are the physical and functional building blocks that enable the platform to operate and manage infrastructure. These include elements like the Meshery Server, Adapters, MeshSync, Broker, and Operator. Each architectural component has a distinct function, such as facilitating communication between cluster components (Broker), managing the lifecycle of deployed components (Operator), or synchronizing state information (MeshSync). Together, these components form a cohesive system that ensures Meshery can effectively integrate with various tools and environments, providing a robust and scalable infrastructure management solution.
+
+* [Adapters](https://docs.meshery.io/concepts/architecture/adapters) \- Adapters extend Meshery's management capabilities in any number of ways, including lifecycle, configuration, performance, governance, identity...
+* [Architecture](https://docs.meshery.io/concepts/architecture) \- overview of different individual components of Meshery architecture and how they interact as a system.
+* [Broker](https://docs.meshery.io/concepts/architecture/broker) \- Meshery broker component facilitates data streaming between kubernetes cluster components and outside world.
+* [Catalog](https://docs.meshery.io/concepts/catalog) \- Browsing and using cloud native patterns
+* [Database](https://docs.meshery.io/concepts/architecture/database) \- Meshery offers support for internal caching with the help of file databases. This has been implemented with several libraries that supports different kinds of data formats.
+* [MeshSync](https://docs.meshery.io/concepts/architecture/meshsync) \- Meshery offers support for Kubernetes cluster and cloud state synchronization with the help of MeshSync.
+* [Operator](https://docs.meshery.io/concepts/architecture/operator) \- Meshery Operator controls and manages the lifecycle of components deployed inside a kubernetes cluster
+
+Logical Components
+
+Logical components in Meshery refer to the conceptual elements that define and organize how infrastructure is managed and operated. These include components like Designs, Patterns, Policies, Environments, Models, and Workspaces. Each logical component has a specific role, such as defining the desired state of infrastructure (Designs), grouping resources (Environments), or enforcing governance rules (Policies). Logical components help structure the management process, making it more systematic and efficient by providing a clear framework for configuration, operation, and collaboration.
+
+* [Components](https://docs.meshery.io/concepts/logical/components) \- Meshery Components identify and characterize infrastructure under management.
+* [Connections](https://docs.meshery.io/concepts/logical/connections) \- Meshery Connections are managed and unmanaged resources that either through discovery or manual entry are managed by a state machine and used within one or more Environments.
+* [Credentials](https://docs.meshery.io/concepts/logical/credentials) \- Meshery uses one or more Credentials when authenticating to a managed or unmanaged Connection.
+* [Designs](https://docs.meshery.io/concepts/logical/designs) \- Meshery Designs are descriptive, declarative characterizations of how your Kubernetes infrastructure should be configured.
+* [Environments](https://docs.meshery.io/concepts/logical/environments) \- Environments are how you organize your deployment targets (whether on-premises servers or cloud services) into resource groups.
+* [Models](https://docs.meshery.io/concepts/logical/models) \- Meshery uses a set of resource models to define concrete boundaries to ensure extensible and sustainable management.
+* [Patterns](https://docs.meshery.io/concepts/logical/patterns) \- Meshery Patterns are descriptive, declarative characterizations of how your Kubernetes infrastructure should be configured.
+* [Policies](https://docs.meshery.io/concepts/logical/policies) \- Meshery Policies enable you with a broad set of controls and governance of the behavior of systems under Meshery's management.
+* [Registry](https://docs.meshery.io/concepts/logical/registry) \- Meshery Registry is a database acting as the central repository for all capabilities known to Meshery. These capabilities encompass various entities, including models, components, relationships, and policies.
+* [Relationships](https://docs.meshery.io/concepts/logical/relationships) \- Meshery Relationships identify and facilitate genealogy between Components.
+* [Workspaces](https://docs.meshery.io/concepts/logical/workspaces) \- Meshery Workspaces act as a central collaboration point for teams.
+
+
\ No newline at end of file
diff --git a/content-learn/mastering-meshery/introduction-to-meshery/meshery/reviewing-designs.mdx b/content-learn/mastering-meshery/introduction-to-meshery/meshery/reviewing-designs.mdx
new file mode 100644
index 000000000000..b6c72bdf31b8
--- /dev/null
+++ b/content-learn/mastering-meshery/introduction-to-meshery/meshery/reviewing-designs.mdx
@@ -0,0 +1,245 @@
+---
+docType: "Chapter"
+id: "reviewing-designs"
+chapterTitle: "Reviewing Designs"
+description: "This chapter explores the essential aspects of reviewing designs in Kanvas, covering the lifecycle of design reviews, the use of comments and annotations, and the best practices for providing constructive feedback. It also details how to effectively collaborate with your team to ensure thorough evaluations and high-quality design outcomes."
+videos: 0
+lectures: 4
+order: 1
+---
+import { ChapterStyle } from "../../../../src/components/Learn-Components/Chapters-Style/chapters.style.js";
+import commentingViaDock from "../../../../src/assets/images/learning-path/reviewing-designs/commenting-via-dock.png";
+import commentingViaMenu from "../../../../src/assets/images/learning-path/reviewing-designs/commenting-via-menu.png";
+import commentsAsDesignTool from "../../../../src/assets/images/learning-path/reviewing-designs/comments-as-design-tool.png";
+import comments from "../../../../src/assets/images/learning-path/reviewing-designs/comments.png";
+import commentHistory from "../../../../src/assets/images/learning-path/reviewing-designs/comment-history.png";
+import reopeningComments from "../../../../src/assets/images/learning-path/reviewing-designs/reopening-comments.png";
+import pinningComments from "../../../../src/assets/images/learning-path/reviewing-designs/pinning-comments.png";
+import lockingComments from "../../../../src/assets/images/learning-path/reviewing-designs/locking-comments.png";
+import annotations from "../../../../src/assets/images/learning-path/reviewing-designs/annotations.png";
+import whiteboarding from "../../../../src/assets/images/learning-path/reviewing-designs/whiteboarding.png";
+import whiteboardAccess from "../../../../src/assets/images/learning-path/reviewing-designs/whiteboard-access.png";
+import shapeAnnotation from "../../../../src/assets/images/learning-path/reviewing-designs/shape-annotation.png";
+import textAnnotation from "../../../../src/assets/images/learning-path/reviewing-designs/text-annotation.png";
+import tooltipAnnotation from "../../../../src/assets/images/learning-path/reviewing-designs/tooltip-annotation.png";
+
+
+
+Introduction
+
+When working with Kanvas’ Designer Mode, collaboration is key. Design reviews allow team members to examine, provide feedback, and approve design proposals, ensuring that all components are thoroughly evaluated and potential issues are identified early. This process leads to more robust designs, informed decision-making, and a unified understanding among team members, ultimately contributing to the success of the project.
+
+Lifecycle of Design Reviews
+
+Submitting Designs
+
+This initial step involves preparing your design to be reviewed by your peers. Start by submitting your design for review, ensuring all components are accurately placed and configured. It is crucial to double-check that every aspect of the design is ready for feedback. In the context of Kanvas, you can submit designs for review by:
+
+* **Ensuring Collaboration is Enabled:** Make sure that [collaboration](https://docs.layer5.io/kanvas/designer/share-resource/#granting-access-for-teams-upcoming-feature) mode is turned on within Kanvas so that your team members can access and review the design.
+* **Having the Design in the Same Workspace/Team:** Place your design in a [workspace or team](https://docs.layer5.io/kanvas/designer/share-resource/#granting-access-for-teams-upcoming-feature) where other members have access. This ensures that all relevant team members can easily find and review the design. Kanvas allows you to manage design access permissions and visibility, ensuring that only the intended collaborators can view and edit the design.
+* **Sharing the Design Link:** Generate and share a link to your design with your team members. This direct approach ensures that anyone with the link can access the design immediately. Ensure that the designs’s [visibility status](https://docs.layer5.io/kanvas/designer/share-resource/#visibility) is set appropriately (Private, Public, or Published) based on who you want to have access.
+ 1. **Private:** Only you, the creator, and the user or team with granted access permission can view and edit the design.
+ 2. **Public:** Anyone within your organization can view, comment on, and edit the design. You can still restrict permissions for individual users or teams.
+ 3. **Published:** The design becomes discoverable to other Meshery users, allowing them to view, download, and clone the design.
+
+By following these steps, you can effectively submit your designs for review within Kanvas, ensuring that they are accessible to the right team members and ready for collaborative feedback.
+
+Reviewing Designs
+
+Team members can review designs using comments or annotations.
+
+Design Reviews with Comments
+
+You can add comments in two convenient ways:
+
+* **Commenting via the Dock:** Click on the comment icon in the dock to create a new comment, or drag and drop it anywhere on the canvas to position it.
+
+
+ 
+
+
+
+* **Commenting via Context Menu in Canvas:"** Right-click anywhere on your canvas and select **“Add Comment Here”** from the context menu or use the shortcut Ctrl + M (Command + M for Mac users). This allows for swift comment placement exactly where you need it.
+
+
+ 
+
+
+Tips for using Comments as a Design Review Tool
+
+
+ 
+
+
+* **Initiating Threads:** You can initiate a comment thread by adding a comment. Your comment may request a design review or provide feedback on a design. Team members can reply directly to comments, creating a structured dialogue around each point of feedback for easy referencing.
+* **Utilize Mentions:** Easily draw the attention of relevant team members by tagging them in your comment. To activate this, type @ in the comment box, and a list of your team members will appear. Select who you want to mention. This ensures that the right people are notified and can contribute to the discussion.
+* **Enable Email Notifications:** Customize your [notification preferences](https://docs.layer5.io/cloud/identity/users/notification-preferences/) to receive emails for comments on your design. When this is enabled, you’ll be notified when comments are made on your design, you’re mentioned in a comment, or someone adds a comment to a thread you’ve previously engaged with.
+* **Mute Comment Notifications:** You can also customize your notification preferences to mute email notifications for comments on your design. This can be useful if you want to temporarily pause notifications or reduce email clutter. You’ll still have access to all comments directly within Kanvas.
+
+
+ 
+
+
+* **Comment on Specific Elements:** Place comments to specific components, whether it’s a shape, text, or an entire component. This specificity ensures that feedback is targeted and directly related to the part of the design under discussion.
+
+Resolving Comments
+
+Once the feedback has been addressed, you can mark the comment as resolved. For resolving comments, simply right click on the comment component and select the **“resolve”** comment action. It closes the comment thread and signifies that the conversation around that feedback has concluded. It helps keep the review process organized and ensures that completed discussions are neatly archived.
+
+**View Comment History**
+
+Even after comments are resolved, you can view the history to understand the decisions and discussions that took place. This feature is beneficial for future reference and maintaining a clear record of the review process.
+
+
+ 
+
+
+Reopening Comments
+
+After a comment has been resolved, there might be situations where you need to reopen the discussion. Unresolving a comment allows you to reinitiate conversations, address additional concerns, or make further changes.
+
+To unresolve a comment:
+* Click on the comment icon at the top right of the design canvas.
+* Select "resolved" from the dropdown menu.
+
+This will show the resolved conversations which can be reopened. This flexibility ensures that ongoing iterations and continuous improvements can be managed effectively.
+
+
+ 
+
+
+By following these steps, you can create a thorough and collaborative review process within Kanvas, ensuring that your designs are vetted comprehensively and efficiently.
+
+Pinning and Locking Comments in Kanvas
+
+1. Pinning of Comments
+
+
+ 
+
+
+This image illustrates the feature of pinning comments to specific nodes within Kanvas. This functionality allows users to attach a comment to a particular node, ensuring that the comment remains associated with the node regardless of its position within the design. This is particularly useful for providing context-specific feedback or instructions that should always be visible alongside the relevant component. You can take a comment icon near to a node and it automatically gets pinned to that node.
+
+**How It Works:**
+
+ * **Attach Comments:** When a comment is pinned to a component, it stays linked to that node. This means that no matter where the node is moved within the design, the comment will follow.
+ * **Contextual Feedback:** This feature helps in maintaining the relevance of the feedback, as the comments are always displayed in relation to the specific node they refer to.
+ * **Collaborative Consistency:** Ensures that all collaborators see the comments in the correct context, facilitating clearer communication and understanding.
+
+2. Locking Comments
+
+
+ 
+
+
+This image shows the locking and unlocking interface for nodes in Kanvas. Right-click on the node to access the “lock” option. Locking a comment ensures that it remains fixed in its position, even if the overall design pattern changes. This is useful for highlighting and securing key components of the design that should not be altered or moved during collaborative sessions.
+
+**How It Works:**
+
+ * **Lock Comments:** By locking a comment, you ensure that it stays in place. This can be particularly useful for critical components that form the backbone of your design.
+ * **Shared Among Collaborators:** When a comment is locked, collaborators working on that design will be unable to move or reposition the locked component. This is an excellent opportunity to brainstorm suggestions for easily identifying locked components.
+ * **Unlocking Comments:** Comments can be unlocked when necessary, allowing for flexibility in design adjustments. This can be done through the radial menu shown in the image, which provides options for copying, resetting styles, duplicating, deleting, and unlocking nodes.
+
+Design Reviews with Annotations
+
+Annotations in Kanvas are a powerful way to add detailed notes and explanations directly onto your design canvas. They are crucial for effective communication, detailed feedback, and collaborative design processes. Here’s how you can effectively use annotations to enhance collaboration and streamline design reviews.
+
+
+ 
+
+
+**Whiteboard in Kanvas**
+
+The whiteboarding feature in Kanvas introduces versatile, freestyle drawing capabilities. Enabling the whiteboard feature augments your ability to diagram with a suite of predefined shapes, and pen and pencil annotations, allowing you full freedom of expression in your engineering diagrams. Annotations are a key part of this feature, enabling you to add contextual information directly to your designs.
+
+
+ 
+
+
+**Key Functionalities**
+
+1. **Drawing Tools Integration:**
+
+ * The whiteboarding feature incorporates a comprehensive set of drawing tools resembling popular whiteboard applications.
+ * It enables you to draw shapes, group components, annotate, and highlight specific elements within the design canvas to help convey complex ideas clearly
+
+2. **Real-time Collaboration:**
+
+ * Facilitates simultaneous collaboration among multiple users within the tool.
+ * Identification of collaborators through avatars ensures clarity in collaborative sessions.
+ * Supports live editing and instant visualization of changes made by collaborators, ensuring everyone is on the same page.
+
+3. **Non-Invasive Annotations:** Annotations, shapes, or drawings created within the tool remain separate visual aids, not altering the actual infrastructure components. This means you can annotate freely without worrying about modifying the core design elements.
+
+4. **Undo/Redo Functionalities:** Allows for design exploration without permanent modifications, enabling you to experiment with different ideas safely.
+
+**Enabling the Whiteboarding Feature**
+
+If the whiteboarding feature is not already enabled, follow these steps to access it within Kanvas:
+
+1. Right-click to open the context menu or Click on the settings icon at the top right of the design canvas.
+2. Select Options to access the Preferences menu.
+3. Enable Whiteboard.
+4. A dock will now appear at the bottom of the canvas, providing access to the whiteboard tools.
+5. Experiment with drawing, annotation, and collaboration functionalities available in the whiteboard toolbar.
+6. Share access with collaborators or team members to engage in real-time collaborative drawing sessions.
+
+
+ 
+
+
+**Customizing Annotations and Shapes**
+
+Customizing annotations and shapes is crucial in design reviews as it enhances clarity and communication within the team. By tailoring annotations and shapes to fit specific needs, team members can highlight important aspects, provide detailed feedback, and visually differentiate components within the design. This level of customization ensures that feedback is clear, actionable, and directly tied to the relevant parts of the design, making the review process more efficient and effective.
+
+1. **Shape Customization:** Shapes within the canvas offer flexibility. Select any shape to access a tooltip with options to resize, reshape, and change colors. This allows for precise adjustments similar to popular design software.
+
+
+ 
+
+
+2. **Text Annotation Customization:** Text annotations come with various options. Customize fonts, sizes, alignments, and styles easily. Text boxes resize for seamless integration with the canvas.
+
+
+ 
+
+
+3. **Interactive Tooltip Interface:** The tooltip is your gateway to customization. It’s simple and intuitive, offering a range of editing options upon selection. It’s designed for easy navigation, mirroring popular design software.
+
+
+ 
+
+
+4. **Advanced Customization Features:**
+ * Manage layers and group elements to organize your design better. These advanced tools ensure collaborative work while preserving design integrity.
+ * Lines and edges are easily manipulated. Adjust thickness, style, and endpoints effortlessly. Drag line segments to create bends or curves, adding detail to visual representations.
+
+5. **Consistent Functionality:** The customization tools apply uniformly to all annotation types. Changes made within the tooltip reflect instantly on the canvas, facilitating real-time collaboration.
+
+**Annotation Use Cases in Design Reviews**
+
+* **Team Collaboration:** Multiple users collaborating on infrastructure designs, adding annotations and insights simultaneously. This helps in gathering diverse perspectives and improving the design quality.
+
+* **Educational Context:** Instructors and students using the tool for visualizing concepts or workflows in remote learning environments. Annotations can be used to highlight key points and provide additional explanations.
+
+* **Documenting Design Decisions:** Annotations help in documenting design decisions and ensuring all stakeholders are aligned.
+
+Annotations in Kanvas’s Designer Mode are an invaluable tool for enhancing collaboration and streamlining the design review process. By integrating versatile drawing tools, enabling real-time collaboration, and preserving the integrity of the infrastructure, annotations provide a powerful way to communicate, document, and iterate on design ideas. Whether you are working in a team, educating others, or planning complex projects, using annotations effectively can significantly improve the quality and clarity of your designs.
+
+**Best Practices for Effective Design Reviews**
+
+* **Provide clear and actionable feedback**
+ Provide specific feedbackthat the designer can act on. Vague comments can lead to misunderstandings and delays in the design process. Support your feedback with examples or references. This can help clarify your point and provide the designer with tangible suggestions for improvement.
+
+* **Balance positive and contructive feedback**
+ Frame feedback in a constructive manner, focusing on how things can be improved rather than just pointing out flaws. Acknowledge what works well in the design before delving into areas that need improvement. This helps maintain a positive and collaborative atmosphere.
+
+* **Regularly check and respond to comments**
+ Stay engaged in the review process. Regularly check and respond to comments to keep the conversation alive and ensure a smooth workflow.
+
+* **Prioritize feedback**
+ Highlight the most critical feedback first. This ensures that the designer focuses on the most important aspects for improvement.
+
+In conclusion, effective design reviews in Kanvas' Designer Mode are essential for fostering collaboration, ensuring clear communication, and achieving high-quality outcomes. By leveraging features like comments, annotations, and customization, teams can provide actionable feedback, maintain design integrity, and align on project goals. Following best practices for feedback and utilizing the full range of tools Kanvas offers will streamline the review process, leading to more robust and well-documented designs.
+
+
\ No newline at end of file