15308555518/ website
1
0
Fork 0
mirror of https://github.com/kubesphere/website.git synced 2025-12-29 15:42:49 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

optimize docs in pluggable components 

Signed-off-by: Bettygogo2021 <bintinggou@yunify.com>
This commit is contained in:
Bettygogo2021 2022-01-14 17:42:24 +08:00
parent ef85244ab4
commit 8564113da3
19 changed files with 162 additions and 160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
content/en/docs/pluggable-components/app-store.md
View File

@ -18,7 +18,7 @@ For more information, see [App Store](../../application-store/).
When you implement multi-node installation of KubeSphere on Linux, you need to create a configuration file, which lists all KubeSphere components.
1. In the tutorial of [Installing KubeSphere on Linux](../../installing-on-linux/introduction/multioverview/), you create a default file `config-sample.yaml`. Modify the file by executing the following command:
1. In the tutorial of [Installing KubeSphere on Linux](../../installing-on-linux/introduction/multioverview/), you create a default file `config-sample.yaml`. Modify the file by running the following command:
```bash
vi config-sample.yaml
@ -28,7 +28,7 @@ When you implement multi-node installation of KubeSphere on Linux, you need to c
If you adopt [All-in-One Installation](../../quick-start/all-in-one-on-linux/), you do not need to create a `config-sample.yaml` file as you can create a cluster directly. Generally, the all-in-one mode is for users who are new to KubeSphere and look to get familiar with the system. If you want to enable the App Store in this mode (for example, for testing purposes), refer to [the following section](#enable-app-store-after-installation) to see how the App Store can be installed after installation.
{{</ notice >}}
2. In this file, navigate to `openpitrix` and change `false` to `true` for `enabled`. Save the file after you finish.
2. In this file, search for `openpitrix` and change `false` to `true` for `enabled`. Save the file after you finish.
```yaml
openpitrix:
@ -52,7 +52,7 @@ As you [install KubeSphere on Kubernetes](../../installing-on-kubernetes/introdu
vi cluster-configuration.yaml
```
2. In this local `cluster-configuration.yaml` file, navigate to `openpitrix` and enable the App Store by changing `false` to `true` for `enabled`. Save the file after you finish.
2. In this local `cluster-configuration.yaml` file, search for `openpitrix` and enable the App Store by changing `false` to `true` for `enabled`. Save the file after you finish.
```yaml
openpitrix:
@ -60,7 +60,7 @@ As you [install KubeSphere on Kubernetes](../../installing-on-kubernetes/introdu
enabled: true # Change "false" to "true".
```
3. Execute the following commands to start installation:
3. Run the following commands to start installation:
```bash
kubectl apply -f https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/kubesphere-installer.yaml
@ -82,7 +82,7 @@ A Custom Resource Definition (CRD) allows users to create a new type of resource
3. In **Custom Resources**, click <img src="/images/docs/enable-pluggable-components/kubesphere-app-store/three-dots.png" height="20px"> on the right of `ks-installer` and select **Edit YAML**.
4. In this YAML file, navigate to `openpitrix` and change `false` to `true` for `enabled`. After you finish, click **OK** in the lower-right corner to save the configuration.
4. In this YAML file, search for `openpitrix` and change `false` to `true` for `enabled`. After you finish, click **OK** in the lower-right corner to save the configuration.
```yaml
openpitrix:
@ -90,7 +90,7 @@ A Custom Resource Definition (CRD) allows users to create a new type of resource
enabled: true # Change "false" to "true".
```
5. You can use the web kubectl to check the installation process by executing the following command:
5. Use the web kubectl to check the installation process by running the following command:
```bash
kubectl logs -n kubesphere-system $(kubectl get pod -n kubesphere-system -l app=ks-install -o jsonpath='{.items[0].metadata.name}') -f

18
content/en/docs/pluggable-components/devops.md
View File

@ -6,9 +6,9 @@ linkTitle: "KubeSphere DevOps System"
weight: 6300
---
The KubeSphere DevOps System is designed for CI/CD workflows in Kubernetes. Based on [Jenkins](https://jenkins.io/), it provides one-stop solutions to help both development and Ops teams build, test and publish apps to Kubernetes in a straight-forward way. It also features plugin management, [Binary-to-Image (B2I)](../../project-user-guide/image-builder/binary-to-image/), [Source-to-Image (S2I)](../../project-user-guide/image-builder/source-to-image/), code dependency caching, code quality analysis, pipeline logging, etc.
The KubeSphere DevOps System is designed for CI/CD workflows in Kubernetes. Based on [Jenkins](https://jenkins.io/), it provides one-stop solutions to help both development and Ops teams build, test and publish apps to Kubernetes in a straight-forward way. It also features plugin management, [Binary-to-Image (B2I)](../../project-user-guide/image-builder/binary-to-image/), [Source-to-Image (S2I)](../../project-user-guide/image-builder/source-to-image/), code dependency caching, code quality analysis, pipeline logging, and more.
The DevOps System offers an enabling environment for users as apps can be automatically released to the same platform. It is also compatible with third-party private image registries (for example, Harbor) and code repositories (for example, GitLab/GitHub/SVN/BitBucket). As such, it creates excellent user experiences by providing users with comprehensive, visualized CI/CD pipelines which are extremely useful in air-gapped environments.
The DevOps System offers an automated environment for users as apps can be automatically released to the same platform. It is also compatible with third-party private image registries (for example, Harbor) and code repositories (for example, GitLab/GitHub/SVN/BitBucket). As such, it creates excellent user experience by providing users with comprehensive, visualized CI/CD pipelines which are extremely useful in air-gapped environments.
For more information, see [DevOps User Guide](../../devops-user-guide/).
@ -18,7 +18,7 @@ For more information, see [DevOps User Guide](../../devops-user-guide/).
When you implement multi-node installation of KubeSphere on Linux, you need to create a configuration file, which lists all KubeSphere components.
1. In the tutorial of [Installing KubeSphere on Linux](../../installing-on-linux/introduction/multioverview/), you create a default file `config-sample.yaml`. Modify the file by executing the following command:
1. In the tutorial of [Installing KubeSphere on Linux](../../installing-on-linux/introduction/multioverview/), you create a default file `config-sample.yaml`. Modify the file by running the following command:
```bash
vi config-sample.yaml
@ -28,7 +28,7 @@ When you implement multi-node installation of KubeSphere on Linux, you need to c
If you adopt [All-in-One Installation](../../quick-start/all-in-one-on-linux/), you do not need to create a `config-sample.yaml` file as you can create a cluster directly. Generally, the all-in-one mode is for users who are new to KubeSphere and look to get familiar with the system. If you want to enable DevOps in this mode (for example, for testing purposes), refer to [the following section](#enable-devops-after-installation) to see how DevOps can be installed after installation.
{{</ notice >}}
2. In this file, navigate to `devops` and change `false` to `true` for `enabled`. Save the file after you finish.
2. In this file, search for `devops` and change `false` to `true` for `enabled`. Save the file after you finish.
```yaml
devops:
@ -51,14 +51,14 @@ As you [install KubeSphere on Kubernetes](../../installing-on-kubernetes/introdu
vi cluster-configuration.yaml
```
2. In this local `cluster-configuration.yaml` file, navigate to `devops` and enable DevOps by changing `false` to `true` for `enabled`. Save the file after you finish.
2. In this local `cluster-configuration.yaml` file, search for `devops` and enable DevOps by changing `false` to `true` for `enabled`. Save the file after you finish.
```yaml
devops:
enabled: true # Change "false" to "true".
```
3. Execute the following commands to start installation:
3. Run the following commands to start installation:
```bash
kubectl apply -f https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/kubesphere-installer.yaml
@ -80,14 +80,14 @@ A Custom Resource Definition (CRD) allows users to create a new type of resource
3. In **Custom Resources**, click <img src="/images/docs/enable-pluggable-components/kubesphere-devops-system/three-dots.png" height="20px"> on the right of `ks-installer` and select **Edit YAML**.
4. In this YAML file, navigate to `devops` and change `false` to `true` for `enabled`. After you finish, click **OK** in the lower-right corner to save the configuration.
4. In this YAML file, search for `devops` and change `false` to `true` for `enabled`. After you finish, click **OK** in the lower-right corner to save the configuration.
```yaml
devops:
enabled: true # Change "false" to "true".
```
5. You can use the web kubectl to check the installation process by executing the following command:
5. Use the web kubectl to check the installation process by running the following command:
```bash
kubectl logs -n kubesphere-system $(kubectl get pod -n kubesphere-system -l app=ks-install -o jsonpath='{.items[0].metadata.name}') -f
@ -111,7 +111,7 @@ Go to **System Components** and check that all components on the **DevOps** tab
{{< tab "Verify the component through kubectl" >}}
Execute the following command to check the status of Pods:
Run the following command to check the status of Pods:
```bash
kubectl get pod -n kubesphere-devops-system

26
content/en/docs/pluggable-components/overview.md
View File

@ -18,7 +18,7 @@ Before you enable pluggable components, make sure you have enough resources in y
{{< notice note >}}
The request and limit of CPU and memory resources all refer to single replica.
The following request and limit of CPU and memory resources are required by a single replica.
{{</ notice >}}
@ -27,9 +27,9 @@ The request and limit of CPU and memory resources all refer to single replica.
| Namespace | openpitrix-system |
| -------------- | ------------------------------------------------------------ |
| CPU Request | 0.3 core |
| CPU Limit | |
| CPU Limit | None |
| Memory Request | 300 MiB |
| Memory Limit | |
| Memory Limit | None |
| Installation | Optional |
| Notes | Provide an App Store with application lifecycle management. The installation is recommended. |
@ -39,9 +39,9 @@ The request and limit of CPU and memory resources all refer to single replica.
| -------------- | ------------------------------------------------------------ | ------------------------------------------------------- |
| Pattern | All-in-One installation | Multi-node installation |
| CPU Request | 34 m | 0.47 core |
| CPU Limit | | |
| CPU Limit | None | None |
| Memory Request | 2.69 G | 8.6 G |
| Memory Limit | | |
| Memory Limit | None | None |
| Installation | Optional | Optional |
| Notes | Provide one-stop DevOps solutions with Jenkins pipelines and B2I & S2I. | The memory of one of the nodes must be larger than 8 G. |
@ -51,11 +51,11 @@ The request and limit of CPU and memory resources all refer to single replica.
| -------------- | ------------------------------------------------------------ | ---------------------------- | ---------------------------- |
| Sub-component | 2 x Prometheus | 3 x Alertmanager | Notification Manager |
| CPU Request | 100 m | 10 m | 100 m |
| CPU Limit | 4 cores | | 500 m |
| CPU Limit | 4 cores | None | 500 m |
| Memory Request | 400 MiB | 30 MiB | 20 MiB |
| Memory Limit | 8 GiB | | 1 GiB |
| Memory Limit | 8 GiB | None | 1 GiB |
| Installation | Required | Required | Required |
| Notes | The memory consumption of Prometheus depends on the cluster size. 8 GiB is sufficient for a cluster with 200 nodes/16,000 Pods. | | |
| Notes | The memory consumption of Prometheus depends on the cluster size. 8 GiB is sufficient for a cluster with 200 nodes/16,000 Pods. | - | - |
{{< notice note >}}
@ -71,7 +71,7 @@ The KubeSphere monitoring system is not a pluggable component. It is installed b
| CPU Request | 50 m | 20 m | 90 m | 20 m |
| CPU Limit | 1 core | 200 m | 900 m | 200 m |
| Memory Request | 2 G | 50 MiB | 120 MiB | 50 MiB |
| Memory Limit | | 100 MiB | 1200 MiB | 100 MiB |
| Memory Limit | None | 100 MiB | 1200 MiB | 100 MiB |
| Installation | Optional | Required | Optional | Optional |
| Notes | An optional component for log data storage. The internal Elasticsearch is not recommended for the production environment. | The log collection agent. It is a required component after you enable logging. | Collecting, filtering, exporting and alerting of Kubernetes events. | Collecting, filtering and alerting of Kubernetes and KubeSphere auditing logs. |
@ -80,9 +80,9 @@ The KubeSphere monitoring system is not a pluggable component. It is installed b
| Namespace | kubesphere-alerting-system |
| -------------- | ------------------------------------------------------------ |
| CPU Request | 0.08 core |
| CPU Limit | |
| CPU Limit | None |
| Memory Request | 80 M |
| Memory Limit | |
| Memory Limit | None |
| Installation | Optional |
| Notes | Alerting and Notification need to be enabled at the same time. |
@ -91,8 +91,8 @@ The KubeSphere monitoring system is not a pluggable component. It is installed b
| Namespace | istio-system |
| -------------- | ------------------------------------------------------------ |
| CPU Request | 1 core |
| CPU Limit | |
| CPU Limit | None |
| Memory Request | 3.5 G |
| Memory Limit | |
| Memory Limit | None |
| Installation | Optional |
| Notes | Support grayscale release strategies, traffic topology, traffic management and distributed tracing. |

14
content/en/docs/pluggable-components/service-mesh.md
View File

@ -6,7 +6,7 @@ linkTitle: "KubeSphere Service Mesh"
weight: 6800
---
On the basis of [Istio](https://istio.io/), KubeSphere Service Mesh visualizes microservices governance and traffic management. It features a powerful toolkit including **circuit breaking, blue-green deployment, canary release, traffic mirroring, tracing, observability, and traffic control**. Developers can easily get started with KubeSphere Service Mesh without any code hacking, with the learning curve of Istio greatly reduced. All features of KubeSphere Service Mesh are designed to meet users' demand for their business.
On the basis of [Istio](https://istio.io/), KubeSphere Service Mesh visualizes microservices governance and traffic management. It features a powerful toolkit including **circuit breaking, blue-green deployment, canary release, traffic mirroring, tracing, observability, and traffic control**. Developers can easily get started with KubeSphere Service Mesh without any code hacking, which greatly reduces the learning curve of Istio. All features of KubeSphere Service Mesh are designed to meet users' demand for their business.
For more information, see [Grayscale Release](../../project-user-guide/grayscale-release/overview/).
@ -33,7 +33,7 @@ If you adopt [All-in-One Installation](../../quick-start/all-in-one-on-linux/),
enabled: true # Change "false" to "true".
```
3. Create a cluster using the configuration file:
3. Run the following command to create a cluster using the configuration file:
```bash
./kk create cluster -f config-sample.yaml
@ -56,7 +56,7 @@ As you [install KubeSphere on Kubernetes](../../installing-on-kubernetes/introdu
enabled: true # Change "false" to "true".
```
3. Execute the following commands to start installation:
3. Run the following commands to start installation:
```bash
kubectl apply -f https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/kubesphere-installer.yaml
@ -83,7 +83,7 @@ A Custom Resource Definition (CRD) allows users to create a new type of resource
enabled: true # Change "false" to "true".
```
5. You can use the web kubectl to check the installation process by executing the following command:
5. Run the following command in kubectl to check the installation process:
```bash
kubectl logs -n kubesphere-system $(kubectl get pod -n kubesphere-system -l app=ks-install -o jsonpath='{.items[0].metadata.name}') -f
@ -100,19 +100,19 @@ You can find the web kubectl tool by clicking <img src="/images/docs/enable-plug
{{< tab "Verify the component on the dashboard" >}}
Go to **System Components** and check that all components on the **Istio** tab page is in **Healthy** state.
Go to **System Components** and check whether all components on the **Istio** tab page is in **Healthy** state. If yes, the component is successfully installed.
{{</ tab >}}
{{< tab "Verify the component through kubectl" >}}
Execute the following command to check the status of Pods:
Run the following command to check the status of Pods:
```bash
kubectl get pod -n istio-system
```
The output may look as follows if the component runs successfully:
The following is an example of the output if the component runs successfully:
```bash
NAME READY STATUS RESTARTS AGE

2
content/zh/docs/pluggable-components/_index.md
View File

@ -10,4 +10,4 @@ weight: 6000
icon: "/images/docs/docs.svg"
---
本章详细演示如何在安装前和安装后启用 KubeSphere 不同组件的详细步骤，以便您可以充分利用该容器平台为您的业务服务。
本章详细演示如何在安装前和安装后启用 KubeSphere 不同组件的步骤，以便您可以充分利用该容器平台为您的业务服务。

14
content/zh/docs/pluggable-components/alerting.md
View File

@ -24,14 +24,14 @@ weight: 6600
如果您采用 [All-in-One 安装](../../quick-start/all-in-one-on-linux/)，则不需要创建 `config-sample.yaml` 文件，因为可以直接创建集群。一般来说，All-in-One 模式针对那些刚接触 KubeSphere 并希望熟悉系统的用户。如果您想在该模式下启用告警系统（例如用于测试），请参考[下面的部分](#在安装后启用告警系统)，查看如何在安装后启用告警系统。
{{</ notice >}}
2. 在该文件中，搜寻到 `alerting` 并将 `enabled` 的 `false` 更改为 `true`。完成后保存文件。
2. 在该文件中，搜索 `alerting` 并将 `enabled` 的 `false` 更改为 `true`。完成后保存文件。
```yaml
alerting:
enabled: true # 将“false”更改为“true”。
```
3. 使用该配置文件创建集群：
3. 执行以下命令使用该配置文件创建集群：
```bash
./kk create cluster -f config-sample.yaml
@ -39,7 +39,7 @@ weight: 6600
### 在 Kubernetes 上安装
[在 Kubernetes 上安装 KubeSphere](../../installing-on-kubernetes/introduction/overview/) 时，您可以先在 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件中启用告警系统。
当您[在 Kubernetes 上安装 KubeSphere](../../installing-on-kubernetes/introduction/overview/) 时，需要先在 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件中启用告警系统。
1. 下载 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件并进行编辑。
@ -47,7 +47,7 @@ weight: 6600
vi cluster-configuration.yaml
```
2. 在该本地 `cluster-configuration.yaml` 文件中，搜寻到 `alerting`，将 `enabled` 的 `false` 更改为 `true` 以启用告警系统。完成后保存文件。
2. 在 `cluster-configuration.yaml` 文件中，搜索 `alerting`，将 `enabled` 的 `false` 更改为 `true` 以启用告警系统。完成后保存文件。
```yaml
alerting:
@ -81,7 +81,7 @@ weight: 6600
enabled: true # 将“false”更改为“true”。
```
5. 您可以使用 Web Kubectl 工具执行以下命令来检查安装过程：
5. 在 kubectl 中执行以下命令检查安装过程：
```bash
kubectl logs -n kubesphere-system $(kubectl get pod -n kubesphere-system -l app=ks-install -o jsonpath='{.items[0].metadata.name}') -f
@ -89,9 +89,9 @@ weight: 6600
{{< notice note >}}
您可以通过点击控制台右下角的 <img src="/images/docs/zh-cn/enable-pluggable-components/kubesphere-alerting/hammer.png" height="20px"> 找到 Web Kubectl 工具。
您可以通过点击控制台右下角的 <img src="/images/docs/zh-cn/enable-pluggable-components/kubesphere-alerting/hammer.png" height="20px"> 找到 kubectl 工具。
{{</ notice >}}
## 验证组件的安装
如果您在**集群管理**页面可以看到**告警消息**和**告警策略**，说明安装成功，因为安装组件之后才会显示这两部分。
如果您可以在**集群管理**页面看到**告警消息**和**告警策略**，则说明安装成功。

21
content/zh/docs/pluggable-components/app-store.md
View File

@ -18,7 +18,7 @@ weight: 6200
当您在 Linux 上安装多节点 KubeSphere 时，首先需要创建一个配置文件，该文件列出了所有 KubeSphere 组件。
1. 基于[在 Linux 上安装 KubeSphere](../../installing-on-linux/introduction/multioverview/) 的教程，您需要创建一个默认文件 `config-sample.yaml`，通过执行以下命令修改该文件：
1. [在 Linux 上安装 KubeSphere](../../installing-on-linux/introduction/multioverview/) 时，您需要创建一个默认文件 `config-sample.yaml`，通过执行以下命令修改该文件：
```bash
vi config-sample.yaml
@ -28,7 +28,7 @@ weight: 6200
如果您采用 [All-in-One 安装](../../quick-start/all-in-one-on-linux/)，则不需要创建 `config-sample.yaml` 文件，因为可以直接创建集群。一般来说，All-in-One 模式是为那些刚接触 KubeSphere 并希望熟悉系统的用户而准备的。如果您想在这个模式下启用应用商店（比如用于测试），请参考[下面的部分](#在安装后启用应用商店)，查看如何在安装后启用应用商店。
{{</ notice >}}
2. 在该文件中，搜寻到 `openpitrix`，并将 `enabled` 的 `false` 改为 `true`，完成后保存文件。
2. 在该文件中，搜索 `openpitrix`，并将 `enabled` 的 `false` 改为 `true`，完成后保存文件。
```yaml
openpitrix:
@ -36,7 +36,7 @@ weight: 6200
enabled: true # 将“false”更改为“true”。
```
3. 使用该配置文件创建集群：
3. 执行以下命令使用该配置文件创建集群：
```bash
./kk create cluster -f config-sample.yaml
@ -44,15 +44,15 @@ weight: 6200
### 在 Kubernetes 上安装
[在 Kubernetes 上安装 KubeSphere](../../installing-on-kubernetes/introduction/overview/) 的教程中说明了在 Kubernetes 上安装 KubeSphere 的流程，不过，需要事先在 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件中启用应用商店（可选系统组件）。
当您[在 Kubernetes 上安装 KubeSphere](../../installing-on-kubernetes/introduction/overview/) 时，需要先在 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件中启用应用商店。
1. 下载 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件，然后打开并开始编辑。
1. 下载 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件，执行以下命令打开并编辑该文件。
```bash
vi cluster-configuration.yaml
```
2. 在该本地 `cluster-configuration.yaml` 文件中，搜寻到 `openpitrix`，并将 `enabled` 的 `false` 改为 `true`，以启用应用商店。完成后保存文件。
2. 在 `cluster-configuration.yaml` 文件中，搜索 `openpitrix`，并将 `enabled` 的 `false` 改为 `true`。完成后保存文件。
```yaml
openpitrix:
@ -70,7 +70,7 @@ weight: 6200
## 在安装后启用应用商店
1. 以 `admin` 身份登录控制台，点击左上角的**平台管理**，选择**集群管理**。
1. 使用 `admin` 用户登录控制台，点击左上角的**平台管理**，选择**集群管理**。
2. 点击 **CRD**，在搜索栏中输入 `clusterconfiguration`，点击结果查看其详细页面。
@ -80,7 +80,7 @@ weight: 6200
3. 在**自定义资源**中，点击 `ks-installer` 右侧的 <img src="/images/docs/zh-cn/enable-pluggable-components/kubesphere-app-store/three-dots.png" height="20px">，选择**编辑 YAML**。
4. 在该 YAML 文件中，搜寻到 `openpitrix`，将 `enabled` 的 `false` 改为 `true`。完成后，点击右下角的**确定**，保存配置。
4. 在该 YAML 文件中，搜索 `openpitrix`，将 `enabled` 的 `false` 改为 `true`。完成后，点击右下角的**确定**，保存配置。
```yaml
openpitrix:
@ -88,7 +88,7 @@ weight: 6200
enabled: true # 将“false”更改为“true”。
```
5. 您可以使用 Web Kubectl 工具执行以下命令来检查安装过程：
5. 在 kubectl 中执行以下命令检查安装过程：
```bash
kubectl logs -n kubesphere-system $(kubectl get pod -n kubesphere-system -l app=ks-install -o jsonpath='{.items[0].metadata.name}') -f
@ -96,7 +96,7 @@ weight: 6200
{{< notice note >}}
您可以通过点击控制台右下角的 <img src="/images/docs/zh-cn/enable-pluggable-components/kubesphere-app-store/hammer.png" height="20px"> 找到 Web Kubectl 工具。
您可以通过点击控制台右下角的 <img src="/images/docs/zh-cn/enable-pluggable-components/kubesphere-app-store/hammer.png" height="20px"> 找到 kubectl 工具。
{{</ notice >}}
## 验证组件的安装
@ -115,3 +115,4 @@ weight: 6200
[在多集群架构中](../../multicluster-management/introduction/kubefed-in-kubesphere/)，一个主集群管理所有成员集群。与 KubeSphere 中的其他组件不同，应用商店是所有集群（包括主集群和成员集群）的全局应用程序池。您只需要在主集群上启用应用商店，便可以直接在成员集群上使用应用商店的相关功能（无论成员集群是否启用应用商店），例如[应用模板](../../project-user-guide/application/app-template/)和[应用仓库](../../workspace-administration/app-repository/import-helm-repository/)。
但是，如果只在成员集群上启用应用商店而没有在主集群上启用，您将无法在多集群架构中的任何集群上使用应用商店。

20
content/zh/docs/pluggable-components/auditing-logs.md
View File

@ -16,7 +16,7 @@ KubeSphere 审计日志系统提供了一套与安全相关并按时间顺序排
当您在 Linux 上安装多节点 KubeSphere 时，需要创建一个配置文件，该文件列出了所有 KubeSphere 组件。
1. 基于[在 Linux 上安装 KubeSphere](../../installing-on-linux/introduction/multioverview/) 的教程，您需要创建一个默认文件 `config-sample.yaml`。执行以下命令修改该文件：
1. [在 Linux 上安装 KubeSphere](../../installing-on-linux/introduction/multioverview/) 时，您需要创建一个默认文件 `config-sample.yaml`。执行以下命令修改该文件：
```bash
vi config-sample.yaml
@ -26,7 +26,7 @@ KubeSphere 审计日志系统提供了一套与安全相关并按时间顺序排
如果您采用 [All-in-One 安装](../../quick-start/all-in-one-on-linux/)，则不需要创建 `config-sample.yaml` 文件，因为可以直接创建集群。一般来说，All-in-One 模式是为那些刚接触 KubeSphere 并希望熟悉系统的用户而准备的，如果您想在该模式下启用审计日志（例如用于测试），请参考[下面的部分](#在安装后启用审计日志)，查看如何在安装后启用审计功能。
{{</ notice >}}
2. 在该文件中，搜寻到 `auditing`，并将 `enabled` 的 `false` 改为 `true`。完成后保存文件。
2. 在该文件中，搜索 `auditing`，并将 `enabled` 的 `false` 改为 `true`。完成后保存文件。
```yaml
auditing:
@ -49,7 +49,7 @@ KubeSphere 审计日志系统提供了一套与安全相关并按时间顺序排
externalElasticsearchPort: # The port of external Elasticsearch.
```
3. 使用该配置文件创建集群：
3. 执行以下命令使用该配置文件创建集群：
```bash
./kk create cluster -f config-sample.yaml
@ -57,15 +57,15 @@ KubeSphere 审计日志系统提供了一套与安全相关并按时间顺序排
### 在 Kubernetes 上安装
在 Kubernetes 上安装 KubeSphere 的过程与教程[在 Kubernetes 上安装 KubeSphere](../../installing-on-kubernetes/introduction/overview/) 中的说明大致相同，不同之处是需要先在 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件中启用审计功能（可选组件）。
当您[在 Kubernetes 上安装 KubeSphere](../../installing-on-kubernetes/introduction/overview/) 时，需要先在 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件中启用审计功能。
1. 下载 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件，然后打开并开始编辑。
1. 下载 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件，执行以下命令打开并编辑该文件：
```bash
vi cluster-configuration.yaml
```
2. 在该本地 `cluster-configuration.yaml` 文件中，搜寻到 `auditing`，并将 `enabled` 的 `false` 改为 `true`。完成后保存文件。
2. 在 `cluster-configuration.yaml` 文件中，搜索 `auditing`，并将 `enabled` 的 `false` 改为 `true`。完成后保存文件。
```yaml
auditing:
@ -98,7 +98,7 @@ KubeSphere 审计日志系统提供了一套与安全相关并按时间顺序排
## 在安装后启用审计日志
1. 以 `admin` 身份登录控制台。点击左上角的**平台管理**，选择**集群管理**。
1. 以 `admin` 用户登录控制台。点击左上角的**平台管理**，选择**集群管理**。
2. 点击 **CRD**，在搜索栏中输入 `clusterconfiguration`，点击搜索结果查看其详细页面。
@ -108,7 +108,7 @@ KubeSphere 审计日志系统提供了一套与安全相关并按时间顺序排
3. 在**自定义资源**中，点击 `ks-installer` 右侧的 <img src="/images/docs/zh-cn/enable-pluggable-components/kubesphere-auditing-logs/three-dots.png" height="20px">，选择**编辑 YAML**。
4. 在该 YAML 文件中，搜寻到 `auditing`，将 `enabled` 的 `false` 改为 `true`。完成后，点击右下角的**确定**，保存配置。
4. 在该 YAML 文件中，搜索 `auditing`，将 `enabled` 的 `false` 改为 `true`。完成后，点击右下角的**确定**，保存配置。
```yaml
auditing:
@ -131,7 +131,7 @@ KubeSphere 审计日志系统提供了一套与安全相关并按时间顺序排
externalElasticsearchPort: # The port of external Elasticsearch.
```
5. 可以执行以下命令，使用 Web Kubectl 工具来检查安装过程：
5. 在 kubectl 中执行以下命令检查安装过程：
```bash
kubectl logs -n kubesphere-system $(kubectl get pod -n kubesphere-system -l app=ks-install -o jsonpath='{.items[0].metadata.name}') -f
@ -139,7 +139,7 @@ KubeSphere 审计日志系统提供了一套与安全相关并按时间顺序排
{{< notice note >}}
您可以点击控制台右下角的 <img src="/images/docs/zh-cn/enable-pluggable-components/kubesphere-auditing-logs/hammer.png" height="20px"> 找到 Web Kubectl 工具。
您可以点击控制台右下角的 <img src="/images/docs/zh-cn/enable-pluggable-components/kubesphere-auditing-logs/hammer.png" height="20px"> 找到 kubectl 工具。
{{</ notice >}}
## 验证组件的安装

24
content/zh/docs/pluggable-components/devops.md
View File

@ -18,7 +18,7 @@ DevOps 系统为用户提供了一个自动化的环境，应用可以自动发
当您在 Linux 上安装多节点 KubeSphere 时，首先需要创建一个配置文件，该文件列出了所有 KubeSphere 组件。
1. 基于[在 Linux 上安装 KubeSphere](../../installing-on-linux/introduction/multioverview/) 的教程，您需要创建一个默认文件 `config-sample.yaml`，通过执行以下命令修改该文件：
1. [在 Linux 上安装 KubeSphere](../../installing-on-linux/introduction/multioverview/) 时，您需要创建一个默认文件 `config-sample.yaml`，通过执行以下命令修改该文件：
```bash
vi config-sample.yaml
@ -28,14 +28,14 @@ DevOps 系统为用户提供了一个自动化的环境，应用可以自动发
如果您采用 [All-in-one 安装](../../quick-start/all-in-one-on-linux/)，则不需要创建 `config-sample.yaml` 文件，因为可以直接创建集群。一般来说，All-in-one 模式是为那些刚接触 KubeSphere 并希望熟悉系统的用户而准备的，如果您想在这个模式下启用 DevOps（比如用于测试），请参考[下面的部分](#在安装后启用-devops)，查看如何在安装后启用 DevOps。
{{</ notice >}}
2. 在该文件中，搜寻到 `devops`，并将 `enabled` 的 `false `改为 `true`，完成后保存文件。
2. 在该文件中，搜索 `devops`，并将 `enabled` 的 `false `改为 `true`，完成后保存文件。
```yaml
devops:
enabled: true # 将“false”更改为“true”。
```
3. 使用该配置文件创建集群：
3. 执行以下命令使用该配置文件创建集群：
```bash
./kk create cluster -f config-sample.yaml
@ -43,15 +43,15 @@ DevOps 系统为用户提供了一个自动化的环境，应用可以自动发
### 在 Kubernetes 上安装
[在 Kubernetes 上安装 KubeSphere](../../installing-on-kubernetes/introduction/overview/) 的教程中说明了在 Kubernetes 上安装 KubeSphere 的流程，不过，需要事先在 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件中启用 DevOps（可选系统组件）。
当您[在 Kubernetes 上安装 KubeSphere](../../installing-on-kubernetes/introduction/overview/) 时，需要先在 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件中启用 DevOps。
1. 下载 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件，然后打开并开始编辑。
1. 下载 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件，执行以下命令打开并编辑该文件：
```bash
vi cluster-configuration.yaml
```
2. 在该本地 `cluster-configuration.yaml` 文件中，搜寻到 `devops`，并将 `enabled` 的 `false` 改为 `true`，完成后保存文件。
2. 在 `cluster-configuration.yaml` 文件中，搜索 `devops`，并将 `enabled` 的 `false` 改为 `true`。完成后保存文件。
```yaml
devops:
@ -68,24 +68,24 @@ DevOps 系统为用户提供了一个自动化的环境，应用可以自动发
## 在安装后启用 DevOps
1. 以 `admin` 身份登录控制台，点击左上角的**平台管理**，选择**集群管理**。
1. 以 `admin` 用户登录控制台，点击左上角的**平台管理**，选择**集群管理**。
2. 点击 **CRD**，在搜索栏中输入 `clusterconfiguration`，点击搜索结果查看其详细页面。
{{< notice info >}}
定制资源定义（CRD）允许用户在不增加额外 API 服务器的情况下创建一种新的资源类型，用户可以像使用其他 Kubernetes 原生对象一样使用这些定制资源。
定制资源定义（CRD）允许用户在不新增 API 服务器的情况下创建一种新的资源类型，用户可以像使用其他 Kubernetes 原生对象一样使用这些定制资源。
{{</ notice >}}
3. 在**自定义资源**中，点击 `ks-installer` 右侧的 <img src="/images/docs/zh-cn/enable-pluggable-components/kubesphere-devops-system/three-dots.png" height="20px">，选择**编辑 YAML**。
4. 在该 YAML 文件中，搜寻到 `devops`，将 `enabled` 的 `false` 改为 `true`。完成后，点击右下角的**确定**，保存配置。
4. 在该 YAML 文件中，搜索 `devops`，将 `enabled` 的 `false` 改为 `true`。完成后，点击右下角的**确定**，保存配置。
```yaml
devops:
enabled: true # 将“false”更改为“true”。
```
5. 您可以使用 Web Kubectl 工具执行以下命令来检查安装过程：
5. 在 kubectl 中执行以下命令检查安装过程：
```bash
kubectl logs -n kubesphere-system $(kubectl get pod -n kubesphere-system -l app=ks-install -o jsonpath='{.items[0].metadata.name}') -f
@ -93,7 +93,7 @@ DevOps 系统为用户提供了一个自动化的环境，应用可以自动发
{{< notice note >}}
您可以通过点击控制台右下角的 <img src="/images/docs/zh-cn/enable-pluggable-components/kubesphere-devops-system/hammer.png" height="20px"> 找到 Web Kubectl 工具。
您可以点击控制台右下角的 <img src="/images/docs/zh-cn/enable-pluggable-components/kubesphere-devops-system/hammer.png" height="20px"> 找到 kubectl 工具。
{{</ notice >}}
## 验证组件的安装
@ -102,7 +102,7 @@ DevOps 系统为用户提供了一个自动化的环境，应用可以自动发
{{< tab "在仪表板中验证组件的安装" >}}
进入**系统组件**，检查 **DevOps** 标签页中的所有组件都处于**健康**状态。
进入**系统组件**，检查是否 **DevOps** 标签页中的所有组件都处于**健康**状态。如果是，组件安装成功。
{{</ tab >}}

16
content/zh/docs/pluggable-components/events.md
View File

@ -16,7 +16,7 @@ KubeSphere 事件系统使用户能够跟踪集群内部发生的事件，例如
当您在 Linux 上安装多节点 KubeSphere 时，需要创建一个配置文件，该文件列出了所有 KubeSphere 组件。
1. 基于[在 Linux 上安装 KubeSphere](../../installing-on-linux/introduction/multioverview/) 的教程，您需要创建一个默认文件 `config-sample.yaml`。通过执行以下命令修改该文件：
1. [在 Linux 上安装 KubeSphere](../../installing-on-linux/introduction/multioverview/) 时，您需要创建一个默认文件 `config-sample.yaml`。执行以下命令修改该文件：
```bash
vi config-sample.yaml
@ -59,7 +59,7 @@ KubeSphere 事件系统使用户能够跟踪集群内部发生的事件，例如
### 在 Kubernetes 上安装
在 Kubernetes 上安装 KubeSphere 的过程与教程[在 Kubernetes 上安装 KubeSphere](../../installing-on-kubernetes/introduction/overview/) 中的说明大致相同，不同之处是需要先在 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件中启用事件系统（可选组件）。
当您[在 Kubernetes 上安装 KubeSphere](../../installing-on-kubernetes/introduction/overview/) 时，需要先在 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件中启用事件系统。
1. 下载 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件，然后打开并开始编辑。
@ -67,7 +67,7 @@ KubeSphere 事件系统使用户能够跟踪集群内部发生的事件，例如
vi cluster-configuration.yaml
```
2. 在该本地 `cluster-configuration.yaml` 文件中，搜寻到 `events`，并将 `enabled` 的 `false` 改为 `true`，启用事件系统。完成后保存文件。
2. 在 `cluster-configuration.yaml` 文件中，搜索 `events`，并将 `enabled` 的 `false` 改为 `true`以启用事件系统。完成后保存文件。
```yaml
events:
@ -100,9 +100,9 @@ KubeSphere 事件系统使用户能够跟踪集群内部发生的事件，例如
## 在安装后启用事件系统
1. 以 `admin` 身份登录控制台。点击左上角的**平台管理**，选择**集群管理**。
1. 使用 `admin` 用户登录控制台。点击左上角的**平台管理**，选择**集群管理**。
2. 点击 **CRD**，在搜索栏中输入 `clusterconfiguration`。点击结果查看其详细页面。
2. 点击 **CRD**，在搜索栏中输入 `clusterconfiguration`。点击结果查看其详情页。
{{< notice info >}}
@ -112,7 +112,7 @@ KubeSphere 事件系统使用户能够跟踪集群内部发生的事件，例如
3. 在**自定义资源**中，点击 `ks-installer` 右侧的 <img src="/images/docs/zh-cn/enable-pluggable-components/kubesphere-events/three-dots.png" height="20px">，选择**编辑 YAML**。
4. 在该 YAML 文件中，搜寻到 `events`，将 `enabled` 的 `false` 改为 `true`。完成后，点击右下角的**确定**，保存配置。
4. 在该配置文件中，搜索 `events`，将 `enabled` 的 `false` 改为 `true`。完成后，点击右下角的**确定**，保存配置。
```yaml
events:
@ -136,7 +136,7 @@ KubeSphere 事件系统使用户能够跟踪集群内部发生的事件，例如
externalElasticsearchPort: # The port of external Elasticsearch.
```
5. 您可以使用 Web Kubectl 工具执行以下命令来检查安装过程：
5. 在 kubectl 中执行以下命令检查安装过程：
```bash
kubectl logs -n kubesphere-system $(kubectl get pod -n kubesphere-system -l app=ks-install -o jsonpath='{.items[0].metadata.name}') -f
@ -144,7 +144,7 @@ KubeSphere 事件系统使用户能够跟踪集群内部发生的事件，例如
{{< notice note >}}
您可以通过点击控制台右下角的 <img src="/images/docs/zh-cn/enable-pluggable-components/kubesphere-events/hammer.png" height="20px"> 找到 Web Kubectl 工具。
您可以通过点击控制台右下角的 <img src="/images/docs/zh-cn/enable-pluggable-components/kubesphere-events/hammer.png" height="20px"> 找到 kubectl 工具。
{{</ notice >}}

14
content/zh/docs/pluggable-components/kubeedge.md
View File

@ -31,7 +31,7 @@ KubeEdge 的组件在两个单独的位置运行——云上和边缘节点上
{{</ notice >}}
2. 在该文件中，搜寻到 `kubeedge.enabled`，然后将 `false` 更改为 `true`。
2. 在该文件中，搜索 `kubeedge.enabled`，然后将 `false` 更改为 `true`。完成后保存文件。
```yaml
kubeedge:
@ -48,7 +48,7 @@ KubeEdge 的组件在两个单独的位置运行——云上和边缘节点上
### 在 Kubernetes 上安装
[在 Kubernetes 上安装 KubeSphere](../../installing-on-kubernetes/introduction/overview/) 时，您可以在 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件中首先启用 KubeEdge。
当您[在 Kubernetes 上安装 KubeSphere](../../installing-on-kubernetes/introduction/overview/) 时，需要先在 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件中启用 KubeEdge。
1. 下载 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件并进行编辑。
@ -56,7 +56,7 @@ KubeEdge 的组件在两个单独的位置运行——云上和边缘节点上
vi cluster-configuration.yaml
```
2. 在本地 `cluster-configuration.yaml` 文件中，搜寻到 `kubeedge.enabled`，将 `false` 更改为 `true` 以启用 KubeEdge。
2. 在本地 `cluster-configuration.yaml` 文件中，搜索 `kubeedge.enabled`，将 `false` 更改为 `true` 以启用 KubeEdge。完成后保存文件。
```yaml
kubeedge:
@ -65,7 +65,7 @@ KubeEdge 的组件在两个单独的位置运行——云上和边缘节点上
3. 将 `kubeedge.cloudCore.cloudHub.advertiseAddress` 的值设置为集群的公共 IP 地址或边缘节点可以访问的 IP 地址。
4. 保存文件并执行以下命令开始安装：
4. 执行以下命令开始安装：
```bash
kubectl apply -f https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/kubesphere-installer.yaml
@ -85,7 +85,7 @@ KubeEdge 的组件在两个单独的位置运行——云上和边缘节点上
3. 在**自定义资源**中，点击 `ks-installer` 右侧的 <img src="/images/docs/zh-cn/enable-pluggable-components/kubeedge/three-dots.png" height="20px">，然后选择**编辑 YAML**。
4. 在该配置文件中，搜寻到 `kubeedge.enabled`，将 `false` 更改为 `true` 以启用 KubeEdge。
4. 在该配置文件中，搜索 `kubeedge.enabled`，将 `false` 更改为 `true` 以启用 KubeEdge。点击右下角的**确定**，保存配置。
```yaml
kubeedge:
@ -94,7 +94,7 @@ KubeEdge 的组件在两个单独的位置运行——云上和边缘节点上
5. 将 `kubeedge.cloudCore.cloudHub.advertiseAddress` 的值设置为集群的公共 IP 地址或边缘节点可以访问的 IP 地址。完成后，点击右下角的**确定**保存配置。
6. 您可以使用 Web Kubectl 执行以下命令查看安装过程：
6. 在 kubectl 中执行以下命令检查安装过程：
```bash
kubectl logs -n kubesphere-system $(kubectl get pod -n kubesphere-system -l app=ks-install -o jsonpath='{.items[0].metadata.name}') -f
@ -102,7 +102,7 @@ KubeEdge 的组件在两个单独的位置运行——云上和边缘节点上
{{< notice note >}}
您可以通过点击控制台右下角的 <img src="/images/docs/zh-cn/enable-pluggable-components/kubeedge/hammer.png" height="20px"> 来找到 Web kubectl 工具。
您可以通过点击控制台右下角的 <img src="/images/docs/zh-cn/enable-pluggable-components/kubeedge/hammer.png" height="20px"> 来找到 kubectl 工具。
{{</ notice >}}
## 验证组件的安装

18
content/zh/docs/pluggable-components/logging.md
View File

@ -16,7 +16,7 @@ KubeSphere 为日志收集、查询和管理提供了一个强大的、全面的
当您在 Linux 上安装 KubeSphere 时，首先需要创建一个配置文件，该文件列出了所有 KubeSphere 组件。
1. 基于[在 Linux 上安装 KubeSphere](../../installing-on-linux/introduction/multioverview/) 的教程，您需要创建一个默认文件 `config-sample.yaml`。通过执行以下命令修改该文件：
1. [在 Linux 上安装 KubeSphere](../../installing-on-linux/introduction/multioverview/) 时，您需要创建一个默认文件 `config-sample.yaml`。通过执行以下命令修改该文件：
```bash
vi config-sample.yaml
@ -57,7 +57,7 @@ KubeSphere 为日志收集、查询和管理提供了一个强大的、全面的
externalElasticsearchPort: # The port of external Elasticsearch.
```
3. 使用配置文件创建一个集群：
3. 使用该配置文件创建集群：
```bash
./kk create cluster -f config-sample.yaml
@ -65,7 +65,7 @@ KubeSphere 为日志收集、查询和管理提供了一个强大的、全面的
### 在 Kubernetes 上安装
[在 Kubernetes 上安装 KubeSphere](../../installing-on-kubernetes/introduction/overview/) 的教程中说明了在 Kubernetes 上安装 KubeSphere 的流程，不过，需要事先在 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件中启用日志系统（可选系统组件）。
当您[在 Kubernetes 上安装 KubeSphere](../../installing-on-kubernetes/introduction/overview/) 时，需要先在 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件中启用日志系统。
1. 下载 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件，然后打开并开始编辑。
@ -73,7 +73,7 @@ KubeSphere 为日志收集、查询和管理提供了一个强大的、全面的
vi cluster-configuration.yaml
```
2. 在该本地 `cluster-configuration.yaml` 文件中，搜寻到 `logging`，并将 `enabled` 的 `false` 改为 `true`，以启用日志系统。完成后保存文件。
2. 在 `cluster-configuration.yaml` 文件中，搜索 `logging`，并将 `enabled` 的 `false` 改为 `true`，以启用日志系统。完成后保存文件。
```yaml
logging:
@ -110,7 +110,7 @@ KubeSphere 为日志收集、查询和管理提供了一个强大的、全面的
## 在安装后启用日志系统
1. 以 `admin` 身份登录控制台。点击左上角的**平台管理**，选择**集群管理**。
1. 以 `admin` 用户登录控制台。点击左上角的**平台管理**，选择**集群管理**。
2. 点击 **CRD**，在搜索栏中输入 `clusterconfiguration`。点击结果查看其详细页面。
@ -122,7 +122,7 @@ KubeSphere 为日志收集、查询和管理提供了一个强大的、全面的
3. 在**自定义资源**中，点击 `ks-installer` 右侧的 <img src="/images/docs/zh-cn/enable-pluggable-components/kubesphere-logging-system/three-dots.png" height="20px">，选择**编辑 YAML**。
4. 在该 YAML 文件中，搜寻到 `logging`，将 `enabled` 的 `false` 改为 `true`。完成后，点击右下角的**确定**，保存配置。
4. 在该 YAML 文件中，搜索 `logging`，将 `enabled` 的 `false` 改为 `true`。完成后，点击右下角的**确定**以保存配置。
```yaml
logging:
@ -149,7 +149,7 @@ KubeSphere 为日志收集、查询和管理提供了一个强大的、全面的
externalElasticsearchPort: # The port of external Elasticsearch.
```
5. 您可以使用 Web Kubectl 工具执行以下命令来检查安装过程：
5. 在 kubectl 中执行以下命令检查安装过程：
```bash
kubectl logs -n kubesphere-system $(kubectl get pod -n kubesphere-system -l app=ks-install -o jsonpath='{.items[0].metadata.name}') -f
@ -157,7 +157,7 @@ KubeSphere 为日志收集、查询和管理提供了一个强大的、全面的
{{< notice note >}}
您可以通过点击控制台右下角的 <img src="/images/docs/zh-cn/enable-pluggable-components/kubesphere-logging-system/hammer.png" height="20px"> 找到 Web Kubectl 工具。
您可以通过点击控制台右下角的 <img src="/images/docs/zh-cn/enable-pluggable-components/kubesphere-logging-system/hammer.png" height="20px"> 找到 kubectl 工具。
{{</ notice >}}
@ -167,7 +167,7 @@ KubeSphere 为日志收集、查询和管理提供了一个强大的、全面的
{{< tab "在仪表板中验证组件的安装" >}}
进入**系统组件**，检查**日志**标签页中的所有组件都处于**健康**状态。
进入**系统组件**，检查**日志**标签页中的所有组件都处于**健康**状态。如果是，组件安装成功。
{{</ tab >}}

18
content/zh/docs/pluggable-components/metrics-server.md
View File

@ -14,7 +14,7 @@ KubeSphere 支持用于[部署](../../project-user-guide/application-workloads/d
当您在 Linux 上安装多节点 KubeSphere 时，首先需要创建一个配置文件，该文件列出了所有 KubeSphere 组件。
1. 基于[在 Linux 上安装 KubeSphere](../../installing-on-linux/introduction/multioverview/) 的教程，您需要创建一个默认文件 `config-sample.yaml`，通过执行以下命令修改该文件：
1. [在 Linux 上安装 KubeSphere](../../installing-on-linux/introduction/multioverview/) 时，您需要创建一个默认文件 `config-sample.yaml`，通过执行以下命令修改该文件：
```bash
vi config-sample.yaml
@ -24,7 +24,7 @@ KubeSphere 支持用于[部署](../../project-user-guide/application-workloads/d
如果您采用 [All-in-One 安装](../../quick-start/all-in-one-on-linux/)，则不需要创建 `config-sample.yaml` 文件，因为可以直接创建集群。一般来说，All-in-One 模式是为那些刚接触 KubeSphere 并希望熟悉系统的用户而准备的。如果您想在这个模式下启用 Metrics Server（比如用于测试），请参考[下面的部分](#在安装后启用应用商店)，查看如何在安装后启用 Metrics Server。
{{</ notice >}}
2. 在该文件中，搜寻到 `metrics_server`，并将 `enabled` 的 `false` 改为 `true`，完成后保存文件。
2. 在该文件中，搜寻到 `metrics_server`，并将 `enabled` 的 `false` 改为 `true`。完成后保存文件。
```yaml
metrics_server:
@ -39,7 +39,7 @@ KubeSphere 支持用于[部署](../../project-user-guide/application-workloads/d
### 在 Kubernetes 上安装
[在 Kubernetes 上安装 KubeSphere](../../installing-on-kubernetes/introduction/overview/) 教程中演示了在 Kubernetes 上安装 KubeSphere 的流程。若想安装可选组件 Metrics Server，您可以先在 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件中先启用该组件。
当您[在 Kubernetes 上安装 KubeSphere](../../installing-on-kubernetes/introduction/overview/) 时，需要先在 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件中先启用 Metrics Server组件。
1. 下载文件 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml)，并打开文件进行编辑。
@ -47,7 +47,7 @@ KubeSphere 支持用于[部署](../../project-user-guide/application-workloads/d
vi cluster-configuration.yaml
```
2. 在本地文件 `cluster-configuration.yaml` 中，导航到 `metrics_server`，并在 `enabled` 一行将 `false` 更改为 `true`。完成之后，请保存文件。
2. 在 `cluster-configuration.yaml` 中，搜索 `metrics_server`，并将 `enabled` 的 `false` 改为 `true`。完成后保存文件。
```yaml
metrics_server:
@ -68,26 +68,26 @@ KubeSphere 支持用于[部署](../../project-user-guide/application-workloads/d
## 在安装后启用 Metrics Server
1. 以 `admin` 身份登录控制台。点击左上角**平台管理**，选择**集群管理**。
1. 以 `admin` 用户登录控制台。点击左上角**平台管理**，选择**集群管理**。
2. 点击 **CRD**，在搜索栏中输入 `clusterconfiguration`。点击搜索结果查看详情页。
{{< notice info >}}
定制资源定义（CRD）能让用户创建新的资源类型，而无需添加其他 API 服务器。用户可以像其他原生 Kubernetes 对象一样使用这些资源。
定制资源定义（CRD）允许用户在不增加额外 API 服务器的情况下创建一种新的资源类型，用户可以像使用其他 Kubernetes 原生对象一样使用这些定制资源。
{{</ notice >}}
3. 在**自定义资源**中，点击 `ks-installer` 右侧的 <img src="/images/docs/zh-cn/enable-pluggable-components/metrics-server/three-dots.png" height="20px">，选择**编辑 YAML**。
4. 在该 YAML 文件中，导航到 `metrics_server`，在 `enabled` 一行将 `false` 更改为 `true`。完成后，点击右下角的**确定**以保存配置。
4. 在该 YAML 文件中，搜索 `metrics_server`，将 `enabled` 的 `false` 改为 `true`。完成后，点击右下角的**确定**以保存配置。
```yaml
metrics_server:
enabled: true # 将“false”更改为“true”。
```
5. 您可以通过执行以下命令，使用 kubectl 来检查安装过程：
5. 在 kubectl 中执行以下命令检查安装过程：
```bash
kubectl logs -n kubesphere-system $(kubectl get pod -n kubesphere-system -l app=ks-install -o jsonpath='{.items[0].metadata.name}') -f
@ -100,7 +100,7 @@ KubeSphere 支持用于[部署](../../project-user-guide/application-workloads/d
## 验证组件的安装
执行以下命令以验证 Metrics Server 的容器组在正常运行。
执行以下命令以验证 Metrics Server 的容器组是否正常运行：
```bash
kubectl get pod -n kube-system

14
content/zh/docs/pluggable-components/network-policy.md
View File

@ -23,7 +23,7 @@ weight: 6900
当您在 Linux 上安装多节点 KubeSphere 时，需要创建一个配置文件，该文件列出了所有 KubeSphere 组件。
1. 基于[在 Linux 上安装 KubeSphere](../../installing-on-linux/introduction/multioverview/) 的教程，您需要创建一个默认文件 `config-sample.yaml`。执行以下命令修改该文件：
1. 在[在 Linux 上安装 KubeSphere](../../installing-on-linux/introduction/multioverview/) 时，您需要创建一个默认文件 `config-sample.yaml`。执行以下命令修改该文件：
```bash
vi config-sample.yaml
@ -33,7 +33,7 @@ weight: 6900
如果您采用 [All-in-One 安装](../../quick-start/all-in-one-on-linux/)，则不需要创建 `config-sample.yaml` 文件，因为可以直接创建集群。一般来说，All-in-One 模式是为那些刚接触 KubeSphere 并希望熟悉系统的用户而准备的。如果您想在该模式下启用网络策略（例如用于测试），可以参考[下面的部分](#在安装后启用网络策略)，查看如何在安装后启用网络策略。
{{</ notice >}}
2. 在该文件中，搜寻到 `network.networkpolicy`，并将 `enabled` 的 `false` 改为 `true`。完成后保存文件。
2. 在该文件中，搜索 `network.networkpolicy`，并将 `enabled` 的 `false` 改为 `true`。完成后保存文件。
```yaml
network:
@ -49,7 +49,7 @@ weight: 6900
### 在 Kubernetes 上安装
在 Kubernetes 上安装 KubeSphere 的过程与教程[在 Kubernetes 上安装 KubeSphere](../../installing-on-kubernetes/introduction/overview/) 中的说明大致相同，不同之处是需要先在 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件中启用网络策略（可选组件）。
当您[在 Kubernetes 上安装 KubeSphere](../../installing-on-kubernetes/introduction/overview/) 时，需要先在 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件中启用网络策略。
1. 下载 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件，然后打开并开始编辑。
@ -57,7 +57,7 @@ weight: 6900
vi cluster-configuration.yaml
```
2. 在该本地 `cluster-configuration.yaml` 文件中，搜寻到 `network.networkpolicy`，并将 `enabled` 的 `false` 改为 `true`，启用该功能。完成后保存文件。
2. 在该本地 `cluster-configuration.yaml` 文件中，搜索 `network.networkpolicy`，并将 `enabled` 的 `false` 改为 `true`。完成后保存文件。
```yaml
network:
@ -93,7 +93,7 @@ weight: 6900
enabled: true # 将“false”更改为“true”。
```
5. 您可以执行以下命令，使用 Web Kubectl 工具来检查安装过程：
5. 在 kubectl 中执行以下命令检查安装过程：
```bash
kubectl logs -n kubesphere-system $(kubectl get pod -n kubesphere-system -l app=ks-install -o jsonpath='{.items[0].metadata.name}') -f
@ -101,9 +101,9 @@ weight: 6900
{{< notice note >}}
您可以通过点击控制台右下角的 <img src="/images/docs/zh-cn/enable-pluggable-components/network-policies/hammer.png" height="20px"> 找到 Web Kubectl 工具。
您可以通过点击控制台右下角的 <img src="/images/docs/zh-cn/enable-pluggable-components/network-policies/hammer.png" height="20px"> 找到 kubectl 工具。
{{</ notice >}}
## 验证组件的安装
如果您能在**网络**中看到**网络策略**，说明安装成功，因为安装组件之后才会显示这部分。
如果您能在**网络**中看到**网络策略**，说明安装成功。

32
content/zh/docs/pluggable-components/overview.md
View File

@ -24,14 +24,14 @@ CPU 和内存的资源请求和限制均指单个副本的要求。
### KubeSphere 应用商店
| 命名空间 | openpitrix-system |
| -------- | -------------------------------------------- |
| CPU 请求 | 0.3 核 |
| CPU 限制 | |
| 内存请求 | 300 MiB |
| 内存限制 | |
| 安装 | 可选 |
| 备注 | 提供应用商店进行应用生命周期管理。建议安装。 |
| 命名空间 | openpitrix-system |
| -------- | ---------------------------------------- |
| CPU 请求 | 0.3 核 |
| CPU 限制 | 无 |
| 内存请求 | 300 MiB |
| 内存限制 | 无 |
| 安装 | 可选 |
| 备注 | 该组件可用于管理应用生命周期。建议安装。 |
### KubeSphere DevOps 系统
@ -39,9 +39,9 @@ CPU 和内存的资源请求和限制均指单个副本的要求。
| -------- | ------------------------------------------------------------ | -------------------------------- |
| 安装模式 | All-in-One 安装 | 多节点安装 |
| CPU 请求 | 34 m | 0.47 核 |
| CPU 限制 | | |
| CPU 限制 | 无 | 无 |
| 内存请求 | 2.69 G | 8.6 G |
| 内存限制 | | |
| 内存限制 | 无 | 无 |
| 安装 | 可选 | 可选 |
| 备注 | 提供一站式 DevOps 解决方案，包括 Jenkins 流水线、B2I 和 S2I。 | 其中一个节点的内存必须大于 8 G。 |
@ -51,7 +51,7 @@ CPU 和内存的资源请求和限制均指单个副本的要求。
| -------- | ------------------------------------------------------------ | ---------------------------- | ---------------------------- |
| 子组件 | 2 x Prometheus | 3 x Alertmanager | Notification Manager |
| CPU 请求 | 100 m | 10 m | 100 m |
| CPU 限制 | 4 core | | 500 m |
| CPU 限制 | 4 core | 无 | 500 m |
| 内存请求 | 400 MiB | 30 MiB | 20 MiB |
| 内存限制 | 8 GiB | | 1 GiB |
| 安装 | 必需 | 必需 | 必需 |
@ -71,7 +71,7 @@ KubeSphere 监控系统不是可插拔组件，会默认安装。它与其他组
| CPU 请求 | 50 m | 20 m | 90 m | 20 m |
| CPU 限制 | 1 core | 200 m | 900 m | 200 m |
| 内存请求 | 2 G | 50 MiB | 120 MiB | 50 MiB |
| 内存限制 | | 100 MiB | 1200 MiB | 100 MiB |
| 内存限制 | 无 | 100 MiB | 1200 MiB | 100 MiB |
| 安装 | 可选 | 必需 | 可选 | 可选 |
| 备注 | 可选组件，用于存储日志数据。不建议在生产环境中使用内置 Elasticsearch。 | 日志收集代理。启用日志系统后，它是必需组件。 | Kubernetes 事件收集、过滤、导出和告警。 | Kubernetes 和 KubeSphere 审计日志收集、过滤和告警。 |
@ -80,9 +80,9 @@ KubeSphere 监控系统不是可插拔组件，会默认安装。它与其他组
| 命名空间 | kubesphere-alerting-system |
| -------- | -------------------------- |
| CPU 请求 | 0.08 core |
| CPU 限制 | |
| CPU 限制 | 无 |
| 内存请求 | 80 M |
| 内存限制 | |
| 内存限制 | 无 |
| 安装 | 可选 |
| 备注 | 告警和通知需要同时启用。 |
@ -91,8 +91,8 @@ KubeSphere 监控系统不是可插拔组件，会默认安装。它与其他组
| 命名空间 | istio-system |
| -------- | ------------------------------------------------------ |
| CPU 请求 | 1 core |
| CPU 限制 | |
| CPU 限制 | 无 |
| 内存请求 | 3.5 G |
| 内存限制 | |
| 内存限制 | 无 |
| 安装 | 可选 |
| 备注 | 支持灰度发布策略、流量拓扑、流量管理和分布式链路追踪。 |

10
content/zh/docs/pluggable-components/pod-ip-pools.md
View File

@ -25,7 +25,7 @@ weight: 6920
{{</ notice >}}
2. 在该文件中，搜寻到 `network.ippool.type`，然后将 `none` 更改为 `calico`。完成后保存文件。
2. 在该文件中，搜索 `network.ippool.type`，然后将 `none` 更改为 `calico`。完成后保存文件。
```yaml
network:
@ -41,7 +41,7 @@ weight: 6920
### 在 Kubernetes 上安装
[在 Kubernetes 上安装 KubeSphere](../../installing-on-kubernetes/introduction/overview/) 时，您可以在 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件中首先启用容器组 IP 池。
当您[在 Kubernetes 上安装 KubeSphere](../../installing-on-kubernetes/introduction/overview/) 时，需要现在 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件中启用容器组 IP 池。
1. 下载 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件并进行编辑。
@ -49,7 +49,7 @@ weight: 6920
vi cluster-configuration.yaml
```
2. 在本地 `cluster-configuration.yaml` 文件中，搜寻到 `network.ippool.type`，将 `none` 更改为 `calico` 以启用容器组 IP 池。完成后保存文件。
2. 在本地 `cluster-configuration.yaml` 文件中，搜索 `network.ippool.type`，将 `none` 更改为 `calico` 以启用容器组 IP 池。完成后保存文件。
```yaml
network:
@ -86,7 +86,7 @@ weight: 6920
type: calico # 将“none”更改为“calico”。
```
5. 您可以使用 Web Kubectl 执行以下命令查看安装过程：
5. 在 kubectl 中执行以下命令检查安装过程：
```bash
kubectl logs -n kubesphere-system $(kubectl get pod -n kubesphere-system -l app=ks-install -o jsonpath='{.items[0].metadata.name}') -f
@ -94,7 +94,7 @@ weight: 6920
{{< notice note >}}
您可以通过点击控制台右下角的 <img src="/images/docs/zh-cn/enable-pluggable-components/pod-ip-pools/hammer.png" height="20px"> 来找到 Web kubectl 工具。
您可以通过点击控制台右下角的 <img src="/images/docs/zh-cn/enable-pluggable-components/pod-ip-pools/hammer.png" height="20px"> 来找到 kubectl 工具。
{{</ notice >}}
## 验证组件的安装

27
content/zh/docs/pluggable-components/service-mesh.md
View File

@ -16,7 +16,7 @@ KubeSphere 服务网格基于 [Istio](https://istio.io/)，将微服务治理和
当您在 Linux 上安装多节点 KubeSphere 时，需要创建一个配置文件，该文件列出了所有 KubeSphere 组件。
1. 基于[在 Linux 上安装 KubeSphere](../../installing-on-linux/introduction/multioverview/) 的教程，您需要创建一个默认文件 `config-sample.yaml`。执行以下命令修改该文件：
1. [在 Linux 上安装 KubeSphere](../../installing-on-linux/introduction/multioverview/) 时，您需要创建一个默认文件 `config-sample.yaml`。执行以下命令修改该文件：
```bash
vi config-sample.yaml
@ -26,14 +26,14 @@ KubeSphere 服务网格基于 [Istio](https://istio.io/)，将微服务治理和
如果您采用 [All-in-One 安装](../../quick-start/all-in-one-on-linux/)，则不需要创建 `config-sample.yaml` 文件，因为可以直接创建集群。一般来说，All-in-One 模式是为那些刚接触 KubeSphere 并希望熟悉系统的用户而准备的。如果您想在该模式下启用服务网格（例如用于测试），请参考[下面的部分](#在安装后启用服务网格)，查看如何在安装后启用服务网格。
{{</ notice >}}
2. 在该文件中，搜寻到 `servicemesh`，并将 `enabled` 的 `false` 改为 `true`。完成后保存文件。
2. 在该文件中，搜索 `servicemesh`，并将 `enabled` 的 `false` 改为 `true`。完成后保存文件。
```yaml
servicemesh:
enabled: true # 将“false”更改为“true”。
```
3. 使用该配置文件创建集群：
3. 执行以下命令使用该配置文件创建集群：
```bash
./kk create cluster -f config-sample.yaml
@ -41,15 +41,15 @@ KubeSphere 服务网格基于 [Istio](https://istio.io/)，将微服务治理和
### 在 Kubernetes 上安装
在 Kubernetes 上安装 KubeSphere 的过程和教程[在 Kubernetes 上安装 KubeSphere](../../installing-on-kubernetes/introduction/overview/) 中的说明大致相同，不同之处是需要先在 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件中启用服务网格（可选组件）。
当您[在 Kubernetes 上安装 KubeSphere](../../installing-on-kubernetes/introduction/overview/) 时，需要先在 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件中启用服务网格。
1. 下载 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件，然后打开并开始编辑。
1. 下载 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件，执行以下命令打开并编辑该文件：
```bash
vi cluster-configuration.yaml
```
2. 在该本地 `cluster-configuration.yaml` 文件中，搜寻到 `servicemesh`，并将 `enabled` 的 `false` 改为 `true`，启用该功能。完成后保存文件。
2. 在 `cluster-configuration.yaml` 文件中，搜索 `servicemesh`，并将 `enabled` 的 `false` 改为 `true`。完成后保存文件。
```yaml
servicemesh:
@ -66,9 +66,9 @@ KubeSphere 服务网格基于 [Istio](https://istio.io/)，将微服务治理和
## 在安装后启用服务网格
1. 以 `admin` 身份登录控制台。点击左上角的**平台管理**，选择**集群管理**。
1. 以 `admin` 用户登录控制台。点击左上角的**平台管理**，选择**集群管理**。
2. 点击 **CRD**，在搜索栏中输入 `clusterconfiguration`。点击结果查看其详细页面。
2. 点击 **CRD**，在搜索栏中输入 `clusterconfiguration`。点击结果查看其详情页。
{{< notice info >}}
定制资源定义（CRD）允许用户在不新增 API 服务器的情况下创建一种新的资源类型，用户可以像使用其他 Kubernetes 原生对象一样使用这些定制资源。
@ -76,14 +76,14 @@ KubeSphere 服务网格基于 [Istio](https://istio.io/)，将微服务治理和
3. 在**自定义资源**中，点击 `ks-installer` 右侧的 <img src="/images/docs/zh-cn/enable-pluggable-components/kubesphere-service-mesh/three-dots.png" height="20px">，选择**编辑 YAML**。
4. 在该 YAML 文件中，搜寻到 `servicemesh`，将 `enabled` 的 `false` 改为 `true`。完成后，点击右下角的**确定**，保存配置。
4. 在该配置文件中，搜索 `servicemesh`，并将 `enabled` 的 `false` 改为 `true`。完成后，点击右下角的**确定**，保存配置。
```yaml
servicemesh:
enabled: true # 将“false”更改为“true”。
```
5. 您可以执行以下命令，使用 Web Kubectl 工具来检查安装过程：
5. 在 kubectl 中执行以下命令检查安装过程：
```bash
kubectl logs -n kubesphere-system $(kubectl get pod -n kubesphere-system -l app=ks-install -o jsonpath='{.items[0].metadata.name}') -f
@ -91,7 +91,8 @@ KubeSphere 服务网格基于 [Istio](https://istio.io/)，将微服务治理和
{{< notice note >}}
您可以通过点击控制台右下角的 <img src="/images/docs/zh-cn/enable-pluggable-components/kubesphere-service-mesh/hammer.png" height="20px"> 找到 Web Kubectl 工具。
您可以通过点击控制台右下角的 <img src="/images/docs/zh-cn/enable-pluggable-components/kubesphere-service-mesh/hammer.png" height="20px"> 找到 kubectl 工具。
{{</ notice >}}
## 验证组件的安装
@ -100,13 +101,13 @@ KubeSphere 服务网格基于 [Istio](https://istio.io/)，将微服务治理和
{{< tab "在仪表板中验证组件的安装" >}}
进入**系统组件**，检查 **Istio** 标签页中的所有组件都处于**健康**状态。
进入**系统组件**，检查 **Istio** 标签页中的所有组件是否都处于**健康**状态。如果是，组件安装成功。
{{</ tab >}}
{{< tab "通过 kubectl 验证组件的安装" >}}
执行以下命令来检查容器组的状态：
执行以下命令检查容器组的状态：
```bash
kubectl get pod -n istio-system

18
content/zh/docs/pluggable-components/service-topology.md
View File

@ -25,7 +25,7 @@ weight: 6915
{{</ notice >}}
2. 在该文件中，搜寻到 `network.topology.type`，然后将 `none` 改为 `weave-scope`。完成后保存文件。
2. 在该文件中，搜索 `network.topology.type`，并将 `none` 改为 `weave-scope`。完成后保存文件。
```yaml
network:
@ -33,7 +33,7 @@ weight: 6915
type: weave-scope # 将“none”更改为“weave-scope”。
```
3. 使用该配置文件创建一个集群：
3. 执行以下命令使用该配置文件创建集群：
```bash
./kk create cluster -f config-sample.yaml
@ -41,7 +41,7 @@ weight: 6915
### 在 Kubernetes 上安装
[在 Kubernetes 上安装 KubeSphere](../../installing-on-kubernetes/introduction/overview/) 时，您可以在 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件中首先启用服务拓扑图。
当您[在 Kubernetes 上安装 KubeSphere](../../installing-on-kubernetes/introduction/overview/) 时，需要先在[cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件中启用服务拓扑图。
1. 下载 [cluster-configuration.yaml](https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/cluster-configuration.yaml) 文件并进行编辑。
@ -49,7 +49,7 @@ weight: 6915
vi cluster-configuration.yaml
```
2. 在本地 `cluster-configuration.yaml` 文件中，搜寻到 `network.topology.type`，将 `none` 更改为 `weave-scope` 以启用服务拓扑图。完成后保存文件。
2. 在 `cluster-configuration.yaml` 文件中，搜索 `network.topology.type`，将 `none` 更改为 `weave-scope` 以启用服务拓扑图。完成后保存文件。
```yaml
network:
@ -57,7 +57,7 @@ weight: 6915
type: weave-scope # 将“none”更改为“weave-scope”。
```
3. 执行以下命令开始安装。
3. 执行以下命令开始安装：
```bash
kubectl apply -f https://github.com/kubesphere/ks-installer/releases/download/v3.2.1/kubesphere-installer.yaml
@ -68,7 +68,7 @@ weight: 6915
## 在安装后启用服务拓扑图
1. 使用 `admin` 用户登录控制台。点击左上角的**平台管理**，然后选择**集群管理**。
1. 以 `admin` 用户登录控制台。点击左上角的**平台管理**，然后选择**集群管理**。
2. 点击 **CRD**，然后在搜索栏中输入 `clusterconfiguration`。点击搜索结果查看其详情页。
@ -86,7 +86,7 @@ weight: 6915
type: weave-scope # 将“none”更改为“weave-scope”。
```
5. 您可以使用 Web Kubectl 执行以下命令查看安装过程：
5. 在 kubectl 中执行以下命令检查安装过程：
```bash
kubectl logs -n kubesphere-system $(kubectl get pod -n kubesphere-system -l app=ks-install -o jsonpath='{.items[0].metadata.name}') -f
@ -94,7 +94,7 @@ weight: 6915
{{< notice note >}}
您可以通过点击控制台右下角的 <img src="/images/docs/zh-cn/enable-pluggable-components/service-topology/hammer.png" height="20px"> 来找到 Web kubectl 工具。
您可以通过点击控制台右下角的 <img src="/images/docs/zh-cn/enable-pluggable-components/service-topology/hammer.png" height="20px"> 来找到 kubectl 工具。
{{</ notice >}}
## 验证组件的安装
@ -107,7 +107,7 @@ weight: 6915
{{</ tab >}}
{{< tab "通过 Kubectl 验证组件的安装" >}}
{{< tab "通过 kubectl 验证组件的安装" >}}
执行以下命令来检查容器组的状态：

4
content/zh/docs/pluggable-components/uninstall-pluggable-components.md
View File

@ -10,7 +10,7 @@ Weight: 6940
{{< notice note >}}
KubeSphere 3.2.x 卸载某些可插拔组件的方法与 KubeSphere v3.0.0 不相同。有关 KubeSphere v3.0.0 卸载可插拔组件的详细方法，请参见[从 KubeSphere 上卸载可插拔组件](https://v3-0.docs.kubesphere.io/zh/docs/faq/installation/uninstall-pluggable-components/)。
KubeSphere 3.2.x 卸载某些可插拔组件的方法与 KubeSphere v3.0.0 不相同。有关 KubeSphere v3.0.0 卸载可插拔组件的详细方法，请参阅从 KubeSphere 上卸载可插拔组件](https://v3-0.docs.kubesphere.io/zh/docs/faq/installation/uninstall-pluggable-components/)。
{{</ notice >}}
@ -19,7 +19,7 @@ KubeSphere 3.2.x 卸载某些可插拔组件的方法与 KubeSphere v3.0.0 不
在卸载除服务拓扑图和容器组 IP 池之外的可插拔组件之前，必须将 CRD 配置文件 `ClusterConfiguration` 中的 `ks-installer` 中的 `enabled` 字段的值从 `true` 改为 `false`。
使用下列其中一方法更改 `enabled` 字段的值：
使用下列任一方法更改 `enabled` 字段的值：
- 运行以下命令编辑 `ks-installer`：