kubernetes
/
website
mirror of https://github.com/kubernetes/website.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

kubernetes-cn-translation-update (#4182) 

* what-is-kubernetes-pr

* kubernetes-basics-pr

* kubernetes-basics-cluster-pr

* kubernetes-basics-deploy-pr

* kubernetes-basics/explore-pr

* kubernetes-basics-expose-pr

* kubernetes-basics-scale-pr

* kuberntes-basics-update-pr

* tutorials-object-management-kubectl-object-management-pr

* tutorials-object-management-kubectl-imperative-object-management-command-pr

* xingzhou-fix-pr
reviewable/pr4229/r4
Dragons 2017-06-30 14:37:40 +08:00 committed by Andrew Chen
parent aae3bfaf3e
commit c7b1119a98
17 changed files with 397 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
cn/docs/concepts/overview/what-is-kubernetes.md
View File

@ -5,14 +5,14 @@ assignees:
title: 认识 Kubernetes?
---
Kubernetes 是一个 [开源的容器调度平台，它可以自动化应用容器的部署、扩展和操作](http://www.slideshare.net/BrianGrant11/wso2con-us-2015-kubernetes-a-platform-for-automating-deployment-scaling-and-operations) 可以跨主机集群, 提供以容器为中心的基础架构。
Kubernetes 是一个跨主机集群的 [开源的容器调度平台，它可以自动化应用容器的部署、扩展和操作](http://www.slideshare.net/BrianGrant11/wso2con-us-2015-kubernetes-a-platform-for-automating-deployment-scaling-and-operations) , 提供以容器为中心的基础架构。
使用 Kubernetes, 您可以快速高效地响应客户需求:
- 快速、可预测地部署您的应用程序
- 拥有即时扩展应用程序的能力
- 不影响现有业务的情况下，无缝地发布新功能。
- 优化您的硬件资源，降低您的拥有成本
- 不影响现有业务的情况下，无缝地发布新功能
- 优化硬件资源，降低成本
我们的目标是构建一个软件和工具的生态系统，以减轻您在公共云或私有云运行应用程序的负担。
@ -36,11 +36,11 @@ Kubernetes 项目由 Google 公司在 2014 年启动。Kubernetes 建立在 [Goo
*新方式* 是基于操作系统级虚拟化而不是硬件级虚拟化方法来部署容器。容器之间彼此隔离并与主机隔离：它们具有自己的文件系统，不能看到彼此的进程，并且它们所使用的计算资源是可以被限制的。它们比虚拟机更容易构建，并且因为它们与底层基础架构和主机文件系统隔离，所以它们可以跨云和操作系统快速分发。
由于容器体积小且启动快，因此可以在每个容器镜像中打包一个应用程序。这种一对一的应用镜像关系拥有很多好处。使用容器，不需要与外部的基础架构环境绑定, 因为每一个应用程序不需要外部依赖，更不需要与外部的基础架构环境依赖。完美解决了从开发到生产环境的一致性问题。
由于容器体积小且启动快，因此可以在每个容器镜像中打包一个应用程序。这种一对一的应用镜像关系拥有很多好处。使用容器，不需要与外部的基础架构环境绑定, 因为每一个应用程序都不需要外部依赖，更不需要与外部的基础架构环境依赖。完美解决了从开发到生产环境的一致性问题。
类似地，容器比虚拟机更加透明，这有助于监测和管理。真实的情况是，容器进程的生命周期由基础设施管理，而容器内的进程对外是隐藏的。最后，每个应用程序用容器封装，管理容器部署就等同于管理应用程序部署。
容器同样比虚拟机更加透明，这有助于监测和管理。尤其是容器进程的生命周期由基础设施管理，而不是由容器内的进程对外隐藏时更是如此。最后，每个应用程序用容器封装，管理容器部署就等同于管理应用程序部署。
容器好处摘要:
容器优点摘要:
* **敏捷的应用程序创建和部署**:
与虚拟机镜像相比，容器镜像更容易创建，提升了硬件的使用效率。
@ -55,7 +55,7 @@ Kubernetes 项目由 Google 公司在 2014 年启动。Kubernetes 建立在 [Goo
* **以应用为中心的管理**:
提升了操作系统的抽象级别，以便在使用逻辑资源的操作系统上运行应用程序。
* **松耦合、分布式、弹性伸缩 [微服务](http://martinfowler.com/articles/microservices.html)**:
应用程序被分成更小，更独立的部分，可以动态部署和管理 - 而不是巨型单体应用运行在专用的大型机。
应用程序被分成更小，更独立的部分，可以动态部署和管理 - 而不是巨型单体应用运行在专用的大型机上。
* **资源隔离**:
通过对应用进行资源隔离，可以很容易的预测应用程序性能。
* **资源利用**:
@ -87,11 +87,11 @@ Kubernetes 满足了生产中运行应用程序的许多常见的需求，例如
#### 为什么 Kubernetes 是一个平台?
Kubernetes 提供了很多的功能，总会有新的场景会受益于新特性。它可以简化应用程序的工作流，加快开发速度。被大家认可的应用编排通常需要有较强的自动化能力。这就是为什么 Kubernetes 被设计作为构建组件和工具的生态系统平台，以便更轻松地部署、扩展和管理应用程序。
Kubernetes 提供了很多的功能，总会有新的场景受益于新特性。它可以简化应用程序的工作流，加快开发速度。被大家认可的应用编排通常需要有较强的自动化能力。这就是为什么 Kubernetes 被设计作为构建组件和工具的生态系统平台，以便更轻松地部署、扩展和管理应用程序。
[Label](/docs/user-guide/labels/) 允许用户按照自己的方式组织管理对应的资源。 [注解](/docs/user-guide/annotations/) 使用户能够以自定义的描述信息来修饰资源，以适用于自己的工作流，并为管理工具提供检查点状态的简单方法。
此外，[Kubernetes 控制面](/docs/admin/cluster-components) 是构建在相同的 [APIs](/docs/api/) 上面，开发员人和用户都可以用。用户可以编写自己的控制器， [调度器](https://git.k8s.io/community/contributors/devel/scheduler.md)等等，如果这么做，根据新加的[自定义 API](https://git.k8s.io/community/contributors/design-proposals/extending-api.md) ，可以扩展当前的通用 [CLI 命令行工具](/docs/user-guide/kubectl-overview/)。
此外，[Kubernetes 控制面 (Controll Plane)](/docs/admin/cluster-components) 是构建在相同的 [APIs](/docs/api/) 上面，开发人员和用户都可以用。用户可以编写自己的控制器， [调度器](https://github.com/kubernetes/kubernetes/tree/{{page.githubbranch}}/docs/devel/scheduler.md)等等，如果这么做，根据新加的[自定义 API](https://github.com/kubernetes/kubernetes/blob/{{page.githubbranch}}/docs/design/extending-api.md) ，可以扩展当前的通用 [CLI 命令行工具](/docs/user-guide/kubectl-overview/)。
这种 [设计](https://git.k8s.io/community/contributors/design-proposals/principles.md) 使得许多其他系统可以构建在 Kubernetes 之上。
@ -116,4 +116,3 @@ Kubernetes 不是一个传统意义上，包罗万象的 PaaS (平台即服务)
#### *Kubernetes* 是什么意思? K8s?
名称 **Kubernetes** 源于希腊语，意为 "舵手" 或 "飞行员"， 且是英文 "governor" 和 ["cybernetic"](http://www.etymonline.com/index.php?term=cybernetics)的词根。 **K8s** 是通过将 8 个字母 "ubernete" 替换为 8 而导出的缩写。另外，在中文里，k8s 的发音与 Kubernetes 的发音比较接近。

2
cn/docs/tutorials/kubernetes-basics/cluster-interactive.html Executable file → Normal file
View File

@ -1,5 +1,5 @@
---
title: 交互式教程 - 创建集群
title: 互动教程 - 创建集群
---
<!DOCTYPE html>

16
cn/docs/tutorials/kubernetes-basics/cluster-intro.html Executable file → Normal file
View File

@ -31,12 +31,12 @@ title: 使用 Minikube 创建一个集群
<div class="col-md-8">
<h3>Kubernetes 集群</h3>
<p>
<b>Kubernetes 用于协调高度可用的计算机集群，这些计算机群集被连接作为单个单元工作。</b> Kubernetes 中的抽象允许您将容器化的应用程序部署到集群，而不必专门将其绑定到单个计算机。为了利用这种新的部署模型，应用程序需要以将它们与各个主机分离的方式打包: 它们需要被容器化。容器化应用程序比过去的部署模型更灵活和可用，其中应用程序直接安装到特定机器上，作为深入集成到主机中的软件包。 <b>Kubernetes 以更有效的方式自动化、跨集群的容器应用程序的分发和调度。</b> Kubernetes 是一个 <a href="https://github.com/kubernetes/kubernetes">开源</a> 平台，为生产环境准备的。
<b>Kubernetes 用于协调高度可用的计算机集群，这些计算机群集被连接作为单个单元工作。</b> Kubernetes 的抽象性允许您将容器化的应用程序部署到集群，而不必专门将其绑定到单个计算机。为了利用这种新的部署模型，应用程序需要以将它们与各个主机分离的方式打包: 它们需要被容器化。容器化应用程序比过去的部署模型更灵活和可用，其中应用程序直接安装到特定机器上，作为深入集成到主机中的软件包。 <b>Kubernetes 在一个集群上以更有效的方式自动分发和调度容器应用程序。</b> Kubernetes 是一个 <a href="https://github.com/kubernetes/kubernetes">开源</a> 平台，可满足生产环境的需要。
</p>
<p>Kubernetes 集群由两种类型的资源组成:
<ul>
<li>一个 <b>Master</b> 调度节点</li>
<li><b>Nodes</b> 应用程序实际运行的地方</li>
<li>一个 <b>Master</b> 是集群的调度节点</li>
<li><b>Nodes</b> 是应用程序实际运行的工作节点</li>
</ul>
</p>
</div>
@ -74,21 +74,21 @@ title: 使用 Minikube 创建一个集群
<div class="row">
<div class="col-md-8">
<p><b>Master 负责管理集群。</b> master 协调集群中的所有活动，例如调度应用程序、维护应用程序的所需状态、扩展应用程序和滚动更新。</p>
<p><b>node 是 Kubernetes 集群中的工作机器，可以是物理机或虚拟机。</b> 每个工作节点都有一个 Kubelet，它是管理 node 并与 Kubernetes Master 节点进行通信的代理。node 上还应具有处理容器操作的工作，例如 <a href="https://www.docker.com/">Docker</a> 或 <a href="https://coreos.com/rkt/">rkt</a>。一个 Kubernetes 工作集群至少有三个 node 节点。</p>
<p><b>节点 是 Kubernetes 集群中的工作机器，可以是物理机或虚拟机。</b> 每个工作节点都有一个 Kubelet，它是管理 节点 并与 Kubernetes Master 节点进行通信的代理。节点 上还应具有处理容器操作的工作，例如 <a href="https://www.docker.com/">Docker</a> 或 <a href="https://coreos.com/rkt/">rkt</a>。一个 Kubernetes 工作集群至少有三个节点。</p>
</div>
<div class="col-md-4">
<div class="content__box content__box_fill">
<p><i> Master 管理集群和 Nodes 用于托管正在运行的应用程序。 </i></p>
<p><i> Master 管理集群，而 节点 用于托管正在运行的应用程序。 </i></p>
</div>
</div>
</div>
<div class="row">
<div class="col-md-8">
<p>当您在 Kubernetes 上部署应用程序时，您可以告诉 master 启动应用程序容器。Master 调度容器在集群的 Node 上运行。<b> Nodes 使用 Master 公开的 Kubernetes API 与 Master 通信</b>。最终用户还可以直接使用 Kubernetes 的 API 与集群交互。</p>
<p>当您在 Kubernetes 上部署应用程序时，您可以告诉 master 启动应用程序容器。Master 调度容器在集群的 节点 上运行。<b> 节点 使用 Master 公开的 Kubernetes API 与 Master 通信</b>。最终用户还可以直接使用 Kubernetes 的 API 与集群交互。</p>
<p>Kubernetes 集群可以部署在物理机或虚拟机上。要开始使用 Kubernetes 开发，您可以使用 <a href="https://github.com/kubernetes/minikube">Minikube</a>。Minikube 是一个轻量级的 Kubernetes 实现，在本机创建一台虚拟机，并部署一个只包含一个节点的简单集群。 Minikube 适用于 Linux, Mac OS 和 Windows 系统。Minikube CLI 提供了集群的基本引导操作，包括启动、停止、状态和删除。但是，对于此基础训练，您将使用预先安装了 Minikube 的在线终端。</p>
<p>Kubernetes 集群可以部署在物理机或虚拟机上。要开始使用 Kubernetes 开发，您可以使用 <a href="https://github.com/kubernetes/minikube">Minikube</a>。Minikube 是一个轻量级的 Kubernetes 实现，会在本机创建一台虚拟机，并部署一个只包含一个节点的简单集群。 Minikube 适用于 Linux, Mac OS 和 Windows 系统。Minikube CLI 提供了集群的基本引导操作，包括启动、停止、状态和删除。为了完成此基础训练，您将使用预先安装了 Minikube 的在线终端。</p>
<p>现在您已经知道 Kubernetes 是什么，让我们使用在线教程，开始我们的第一个集群!</p>
@ -98,7 +98,7 @@ title: 使用 Minikube 创建一个集群
<div class="row">
<div class="col-md-12">
<a class="btn btn-lg btn-success" href="/docs/tutorials/kubernetes-basics/cluster-interactive/" role="button">启动交互教程 <span class="btn__next">›</span></a>
<a class="btn btn-lg btn-success" href="/docs/tutorials/kubernetes-basics/cluster-interactive/" role="button">启动互动教程 <span class="btn__next">›</span></a>
</div>
</div>

2
cn/docs/tutorials/kubernetes-basics/deploy-interactive.html Executable file → Normal file
View File

@ -1,5 +1,5 @@
---
title: 交互式教程 - 部署应用程序
title: 互动教程 - 部署应用程序
---
<!DOCTYPE html>

16
cn/docs/tutorials/kubernetes-basics/deploy-intro.html Executable file → Normal file
View File

@ -30,9 +30,9 @@ title: 使用 kubectl 创建部署
一旦运行了 Kubernetes 集群，您可以在其上部署容器化应用程序。为此，您可以创建一个 Kubernetes <b>Deployment</b>。Deployment 负责创建和更新应用程序实例。创建 Deployment 后， Kubernetes master 会将 Deployment 创建的应用程序实例调度到集群中的各个节点。
</p>
<p>创建应用程序实例后，Kubernetes Deployment 控制器会持续监视这些实例。如果托管它的节点不可用或删除，则 Deployment 控制器将替换实例。 <b>这提供了一种解决机器故障或维护的自愈机制。</b></p>
<p>创建应用程序实例后，Kubernetes 部署控制器会持续监视这些实例。如果托管它的节点不可用或删除，则部署控制器将替换实例。 <b>这提供了一种解决机器故障或维护的自愈机制。</b></p>
<p>在编排前的世界中，通常会使用安装脚本启动应用程序，但是它们并不能从机器故障中恢复。通过创建应用程序实例并使其运行在跨节点的机器之间，Kubernetes Deployments 提供了截然不同的应用管理方法。 </p>
<p>在编排诞生前的世界中，通常会使用安装脚本启动应用程序，但是它们并不能从机器故障中恢复。通过创建应用程序实例并使其运行在跨节点的机器之间，Kubernetes 部署提供了截然不同的应用管理方法。 </p>
</div>
@ -40,13 +40,13 @@ title: 使用 kubectl 创建部署
<div class="content__box content__box_lined">
<h3>概要:</h3>
<ul>
<li>Deployments</li>
<li>部署</li>
<li>Kubectl</li>
</ul>
</div>
<div class="content__box content__box_fill">
<p><i>
Deployment 负责创建和更新应用程序的实例
部署负责创建和更新应用程序的实例
</i></p>
</div>
</div>
@ -69,9 +69,9 @@ title: 使用 kubectl 创建部署
<div class="row">
<div class="col-md-8">
<p>您可以使用 Kubernetes 命令行工具 <b>Kubectl</b>创建和管理 Deployment。Kubectl 使用 Kubernetes API 与集群进行交互。在本模块中，您将学习在 Kubernetes 集群上运行应用程序部署所需的最常见 Kubectl 命令。</p>
<p>您可以使用 Kubernetes 命令行工具 <b>Kubectl</b>创建和管理部署。Kubectl 使用 Kubernetes API 与集群进行交互。在本模块中，您将学习在 Kubernetes 集群上运行应用程序部署所需的最常见的 Kubectl 命令。</p>
<p>创建部署时，您需要为应用程序指定容器镜像以及要运行的副本数。您可以稍后通过更新部署来更改该信息；模块 <a href="/docs/tutorials/kubernetes-basics/scale-intro/">5</a> 和 <a href="/docs/tutorials/kubernetes-basics/update-intro/">6</a> 是一个基础训练讨论如何扩展和更新您的部署。</p>
<p>创建部署时，您需要为应用程序指定容器镜像以及要运行的副本数。您可以稍后通过更新部署来更改该信息；基础训练模块 <a href="/docs/tutorials/kubernetes-basics/scale-intro/">5</a> 和 <a href="/docs/tutorials/kubernetes-basics/update-intro/">6</a> 讨论如何扩展和更新您的部署。</p>
@ -86,7 +86,7 @@ title: 使用 kubectl 创建部署
<div class="row">
<div class="col-md-8">
<p>对于我们的第一个部署，我们将使用 <a href="https://nodejs.org">Node.js</a> 应用程序打包到 Docker 容器。源代码和 Dockerfile 可在 Kubernetes Bootcamp <a href="https://github.com/kubernetes/kubernetes-bootcamp">GitHub 存储库</a> 中找到。</p>
<p>对于我们的第一个部署，我们将使用 <a href="https://nodejs.org">Node.js</a> 应用程序打包到 Docker 容器。源代码和 Dockerfile 可在 Kubernetes Bootcamp 的 <a href="https://github.com/kubernetes/kubernetes-bootcamp">GitHub 存储库</a> 中找到。</p>
<p>现在您已经知道部署是什么，我来再来看看在线教程，并部署我们的第一个应用程序!</p>
@ -96,7 +96,7 @@ title: 使用 kubectl 创建部署
<div class="row">
<div class="col-md-12">
<a class="btn btn-lg btn-success" href="/docs/tutorials/kubernetes-basics/deploy-interactive/" role="button">启动交互式教程 <span class="btn__next">›</span></a>
<a class="btn btn-lg btn-success" href="/docs/tutorials/kubernetes-basics/deploy-interactive/" role="button">启动互动教程 <span class="btn__next">›</span></a>
</div>
</div>

2
cn/docs/tutorials/kubernetes-basics/explore-interactive.html Executable file → Normal file
View File

@ -1,5 +1,5 @@
---
title: 交互式教程 - 应用程序探索
title: 互动教程 - 应用程序探索
---
<!DOCTYPE html>

30
cn/docs/tutorials/kubernetes-basics/explore-intro.html Executable file → Normal file
View File

@ -1,5 +1,5 @@
---
title: 查看 Pods 和 Nodes
title: 查看 Pods 和节点
---
<!DOCTYPE html>
@ -22,7 +22,7 @@ title: 查看 Pods 和 Nodes
<ul>
<li>了解 Kubernetes Pods</li>
<li>了解 Kubernetes Nodes</li>
<li>已部署应用故障排除</li>
<li>已部署应用的故障排除</li>
</ul>
</div>
@ -34,9 +34,9 @@ title: 查看 Pods 和 Nodes
<li>网络，作为唯一的集群 IP 地址</li>
<li>每个容器如何运行的信息，例如容器镜像版本或要使用的特定端口</li>
</ul>
<p>Pod 模型可以理解为应用程序特定的 "逻辑主机"，并且可以包含相对紧密耦合的不同应用程序容器。例如，Pod 可能包含带有 Node.js 应用程序的容器以及用于提供要由 Node.js Web 服务器发布数据的不同容器。Pod 中的容器共享 IP 地址和端口空间，始终位于同一位置并且统一调度，并在相同的节点上运行，共享上下文环境。</p>
<p>Pod 模型可以理解为应用程序特定的 "逻辑主机"，并且可以包含相对紧密耦合的不同应用程序容器。例如，Pod 可能包含带有 Node.js 应用程序的容器以及另一个要吸收 Node.js Web 服务器提供的数据的不同容器。Pod 中的容器共享 IP 地址和端口空间，始终位于同一位置并且统一调度，并在相同的节点上运行，共享上下文环境。</p>
<p>Pods 是 Kubernetes 平台上的原子单元。当我们在 Kubernetes 上创建一个部署时，该部署将在其中创建包含容器的 Pod (而不是直接创建容器)。每个 Pod 绑定到它被调度的节点，并且保持在那里，直到终止 (根据重启策略) 或删除。在节点故障的情况下，在集群中的其他可用节点上调度相同的 Pod。</p>
<p>Pods 是 Kubernetes 平台上原子级别的单元。当我们在 Kubernetes 上创建一个部署时，该部署将在其中创建包含容器的 Pod (而不是直接创建容器)。每个 Pod 都绑定到它被调度的节点，并且始终在那里，直到终止 (根据重启策略) 或删除。在节点故障的情况下，在集群中的其他可用节点上调度相同的 Pod。</p>
</div>
<div class="col-md-4">
@ -44,13 +44,13 @@ title: 查看 Pods 和 Nodes
<h3>概要:</h3>
<ul>
<li>Pods</li>
<li>Nodes</li>
<li>节点</li>
<li>Kubectl 主要命令</li>
</ul>
</div>
<div class="content__box content__box_fill">
<p><i>
Pod 是一组或多个应用程序容器 (例如 Docker 或 rkt)，包含共享存储 (卷)，IP 地址以及有关如何运行它们的信息。
Pod是由一个或者多个应用程序容器构成的(例如 Docker 或 rkt)，包含共享存储 (卷)，IP 地址以及有关如何运行它们的信息。
</i></p>
</div>
</div>
@ -72,19 +72,19 @@ title: 查看 Pods 和 Nodes
<div class="row">
<div class="col-md-8">
<h2>Nodes</h2>
<p>Pod 总是运行在 <b>Node</b>上。Node 是 Kubernetes 的工作机器，可以是一个虚拟机或物理，这取决于在集群的安装情况。每个 Node 由 Master 管理。一个 Node 上可以有多个 Pod, Kubernetes master 会自动处理调度集群各个 Node 上的 Pod。 Master 在自动调度时，会考虑每个 Node 上的可用资源。</p>
<h2>节点</h2>
<p>Pod 总是运行在 <b>Node</b>上。Node 是 Kubernetes 的工作机器，可以是虚拟机或物理机，这取决于在集群的安装情况。每个节点由 Master 管理。一个节点上可以有多个 Pod, Kubernetes master 会自动处理调度集群各个节点上的 Pod。 Master 在自动调度时，会考虑每个 Node 上的可用资源。</p>
<p>每个 Kubernetes Node 节点至少运行以下组件:</p>
<p>每个 Kubernetes 节点至少运行以下组件:</p>
<ul>
<li>Kubelet 是负责 Kubernetes Master 和 所有 Node 节点之间通信的进程，它管理机器上运行的 Pod 和容器。</li>
<li>Kubelet 是负责 Kubernetes Master 和 所有节点之间通信的进程，它管理机器上运行的 Pod 和容器。</li>
<li>容器运行时(例如 Docker, rkt) 负责从镜像仓库中拉取容器镜像，解包容器并运行应用程序。</li>
</ul>
</div>
<div class="col-md-4">
<div class="content__box content__box_fill">
<p><i> 如果一些容器强耦合并且需要共享资源(例如 磁盘)，那么这些容器应该放到单个 Pod 中一起调度。 </i></p>
<p><i> 如果一些容器属于强耦合并且需要共享资源(例如 磁盘)，那么这些容器应该放到单个 Pod 中一起调度。 </i></p>
</div>
</div>
</div>
@ -93,7 +93,7 @@ title: 查看 Pods 和 Nodes
<div class="row">
<div class="col-md-8">
<h2 style="color: #3771e3;">Node 概述</h2>
<h2 style="color: #3771e3;">节点概述</h2>
</div>
</div>
@ -107,7 +107,7 @@ title: 查看 Pods 和 Nodes
<div class="row">
<div class="col-md-8">
<h2>使用 kubectl 进行故障排除</h2>
<p>在模块 <a href="/docs/tutorials/kubernetes-basics/deploy-intro/">2</a>中，您使用了 Kubectl 命令行接口。您将在模块 3 中继续使用它来获取有关已部署应用程序及其环境信息。最常见的操作可以通过以下 kubectl 命令完成:</p>
<p>在模块 <a href="/docs/tutorials/kubernetes-basics/deploy-intro/">2</a>中，您使用了 Kubectl 命令行接口。您将在模块 3 中继续使用它来获取有关已部署应用程序及其环境的信息。最常见的操作可以通过以下 kubectl 命令完成:</p>
<ul>
<li><b>kubectl get</b> - 列出可用资源</li>
<li><b>kubectl describe</b> - 显示有关资源的详细信息</li>
@ -122,7 +122,7 @@ title: 查看 Pods 和 Nodes
</div>
<div class="col-md-4">
<div class="content__box content__box_fill">
<p><i> Node 是 Kubernetes 中的工作机器，可能是物理机或虚拟机，具体取决于集群的安装配置。多个 Pod 可以在一个 Node 上运行。 </i></p>
<p><i> 节点是 Kubernetes 中的工作机器，可能是物理机或虚拟机，具体取决于集群的安装配置。多个 Pod 可以在一个节点上运行。 </i></p>
</div>
</div>
</div>
@ -130,7 +130,7 @@ title: 查看 Pods 和 Nodes
<div class="row">
<div class="col-md-12">
<a class="btn btn-lg btn-success" href="/docs/tutorials/kubernetes-basics/explore-interactive/" role="button">启动交互式教程<span class="btn__next">›</span></a>
<a class="btn btn-lg btn-success" href="/docs/tutorials/kubernetes-basics/explore-interactive/" role="button">启动互动教程<span class="btn__next">›</span></a>
</div>
</div>

2
cn/docs/tutorials/kubernetes-basics/expose-interactive.html Executable file → Normal file
View File

@ -1,5 +1,5 @@
---
title: 交互性教程 - 应用外部可见
title: 互动教程 - 应用外部可见
---
<!DOCTYPE html>

89
cn/docs/tutorials/kubernetes-basics/expose-intro.html Executable file → Normal file
View File

@ -1,5 +1,5 @@
---
title: 使用服务让您的应用程序外部可见
title: 使用服务发布您的应用程序
---
<!DOCTYPE html>
@ -15,40 +15,41 @@ title: 使用服务让您的应用程序外部可见
<main class="content">
<div class="row">
<div class="col-md-8">
<h3>目标</h3>
<div class="col-md-8">
<h3>目标</h3>
<ul>
<li>了解 Kubernetes 服务</li>
<li>了解 Kubernetes 标签</li>
<li>应用程序在 Kubernetes 外部可见</li>
<li>了解 Kubernetes 中的服务</li>
<li>了解标签和标签选择器对象如何与服务相关联</li>
<li>通过 Service 在 Kubernetes 集群外发布应用程序</li>
</ul>
</div>
<div class="col-md-8">
<h3>Kubernetes Services</h3>
<h3>Kubernetes 服务概述</h3>
<p>虽然每个 Pod 在所在的集群中拥有自己独立的 IP 地址，但这些 IP 地址不会暴露在 Kubernetes 集群外部。考虑到 Pod 可能随时会被终止、删除或被其他 Pod 替换，我们需要一种方法让其他 Pod 和应用程序自动发现彼此。Kubernetes 通过 Service 对 Pods 进行分组来解决此问题。一个 Kubernetes <b>Service</b> 是一个抽象层，它定义了一组逻辑的 Pods，并让这些 Pods 对外部流量可见，可以被负载均衡和服务发现。 </p>
<p>Kubernetes <a href="/docs/concepts/workloads/pods/pod-overview/">Pods</a> 终有一死. Pods 实际上有一个 <a href="/docs/concepts/workloads/pods/pod-lifecycle/">生命周期</a>. 当工作节点死机时, 节点上运行的Pod也将丢失。 一个 <a href="/docs/user-guide/replication-controller/#what-is-a-replicationcontroller">ReplicationController</a> 可能会通过创建新的Pod以动态地将集群恢复到所需的状态，以保持您的应用程序运行。还有一种方法就是：决定是否使用具有3个副本的图像处理后端。这些副本是可替代的前端系统不应关心后端副本，即使Pod丢失并重建也不会更改。 也就是说，Kubernetes 集群中的每个 Pod 都有一个唯一的IP地址，即使在同一个节点上的 Pods 也是如此，所以此时就需要一种自动调整更改 Pod 的方法, 以便您的应用程序继续运行。输入 <i>服务</i>. Kubernetes 中的服务是一个抽象对象，它定义了一组逻辑的 Pods 和一个访问它们的策略。 服务让互相依赖的 Pod 之间的耦合松动。 服务由 YAML <a href="/docs/concepts/configuration/overview/#general-config-tips">(首选)</a> 或 JSON 定义。像所有 Kubernetes 对象一样。 针对服务的一组 Pod 通常由<i>Label选择器</i>确定（参见下文，为什么您可能希望不将 <code>选择器</code> 包含在规范中。</p>
<p>此抽象允许我们将 Pods 暴露给集群外部的流量访问。Services 具有自己的唯一集群专用 IP 地址，并显示一个端口以接收流量。如果选择在集群外公开 Service，则有如下选项:</p>
<p>虽然每个 Pod 都有一个唯一的 IP 地址，但是这些 IP 不会在没有服务的情况下公开在群集之外。服务允许您的应用程序接收流量。 可以通过在 ServiceSpec 中指定<code>类型</code> 以不同方式显示服务：</p>
<ul>
<li>LoadBalancer - 提供公有 IP 地址 (在 GCP 或 AWS 上运行 Kubernetes 通常使用此方式)</li>
<li>NodePort - 使用 NAT 在集群的每个 Node 节点的同一端口让服务可见。(所有 Kubernetes 集群和 Minikube 中都可用此方式)</li>
<li><i>ClusterIP</i>(默认) - 在集群中的内部IP上公开服务。此类型使服务只能从集群中访问。</li>
<li><i>NodePort</i> —— 使用NAT在群集中每个选定的节点的同一端口上显示该服务。使用 <code><NodeIP>:<NodePort></code>可以从群集外部访问服务。建立 ClusterIP 的超集.</li>
<li><i>LoadBalancer</i> —— 在当前云中创建外部负载平衡器(如果支持)，并为服务分配固定的外部IP。建立 NodePort 的超集。</li>
<li><i>ExternalName</i> —— 使用任意名称显示该服务(由规范中的<code>externalName</code> 指定)，本过程通过使用该名称返回 CNAME 记录达成。无须使用代理。这种类型需要 v1.7 或更高版本的 <code>kube-dns</code>.</li>
</ul>
<p>有关不同类型服务的详细信息，请参见 <a href="/docs/tutorials/services/source-ip/">使用源IP</a> 教程。另请参阅 <a href="/docs/concepts/services-networking/connect-applications-service">使用服务连接应用程序</a>.</p>
<p>另外，请注意，服务中有一些使用案例涉及在规范中不定义<code>选择器</code> 。不使用 <code>选择器</code> 创建的服务也不会创建相应的端点对象。 这允许用户手动将服务映射到特定端点。没有选择器还有可能是因为您严格地使用了 <code>type: ExternalName</code>.</p>
</div>
<div class="col-md-4">
<div class="content__box content__box_lined">
<h3>摘要:</h3>
<h3>摘要</h3>
<ul>
<li>Pod 流量外部可见</li>
<li>Pods 流量负载均衡</li>
<li>对外部流量曝光 Pod </li>
<li>跨多个 Pods 进行流量负载均衡</li>
<li>使用标签</li>
</ul>
</div>
<div class="content__box content__box_fill">
<p><i>
Kubernetes Service 是一个抽象层，它定义了一组逻辑的 Pods，并为这些 Pods 启用了外部流量访问、负载均衡和服务发现。
</i></p>
<p><i>Kubernetes 服务是一个抽象层，它定义了一组逻辑的Pods，并为这些Pods启用了外部流量曝光、负载平衡和服务发现。</i></p>
</div>
</div>
</div>
@ -56,57 +57,35 @@ title: 使用服务让您的应用程序外部可见
<div class="row">
<div class="col-md-8">
<h2 style="color: #3771e3;">Services 概述</h2>
<h3>服务和标签</h3>
</div>
</div>
<div class="row">
<div class="col-md-8">
<p><img src="/docs/tutorials/kubernetes-basics/public/images/module_04_services.svg"></p>
</div>
</div>
<br>
<div class="row">
<div class="col-md-8">
<p>一个 Service 提供了一组 Pods 的流量负载均衡。通过创建服务以对来自特定部署的所有 Pods 进行分组时，这是有用的(当我们有多个实例运行时，我们的应用程序将在下一个模块中使用这一点)。</p>
<p>Services 还负责集群内部的服务发现 (包含在 <a href="/docs/user-guide/connecting-applications/#accessing-the-service">访问服务</a>中)。 例如，这将允许前端服务 (如 web 服务器) 从后端服务 (如 数据库) 接收流量，而不必考虑 Pod。 </p>
<p>Services 使用标签选择器匹配一组 Pods，标签选择器支持在标签上进行原始逻辑分组的能力。</p>
</div>
<div class="col-md-4">
<div class="content__box content__box_fill">
<p><i> 您可以通过添加 --expose 作为 kubectl 运行命令的参数，在创建 Deployment 的同时创建 Service。 </i></p>
</div>
<p><img src="/docs/tutorials/kubernetes-basics/public/images/module_04_services.svg" width="150%" height="150%"></p>
</div>
</div>
<br>
<div class="row">
<div class="col-md-8">
<p><b>Labels</b> 是附加到对象的 键/值对，例如 Pods，您可以将它们视为社交媒体的标签符号。它们用于以对用户有意义的方式组织相关对象，如:</p>
<p> A服务可以跨一组 Pod 路由流量。服务是允许 Pod 在 Kubernetes 中死亡和复制而不影响应用程序的抽象层。相关 Pod 之间的发现和路由(如应用程序中的前端和后端组件)是由 Kubernetes Services 处理的。</p>
<p> 服务使用 <a href="/docs/concepts/overview/working-with-objects/labels">标签和选择器</a>, 匹配一组 Pod，成为分组原语，此原语允许在 Kubernetes 中的对象进行逻辑运算。标签是一对附加到对象的关键/重要组，可以以多种方式使用，方式如下: </p>
<ul>
<li>生产环境 (生产、测试、开发)</li>
<li>应用程序版本 (beta、v1.3)</li>
<li>服务类型 (前端、后端、数据库)</li>
<li>指定用于开发、测试和生产的对象</li>
<li>嵌入版本标签</li>
<li>使用标签分类对象</li>
</ul>
</div>
<div class="col-md-4">
<div class="content__box content__box_fill">
<p><i> Labels 是附加到对象的键/值对。</i></p>
<p><i>您可以在使用<br><code>--expose</code> 在 kubectl 中创建部署的同时创建服务.</i></p>
</div>
</div>
</div>
<br>
<div class="row">
<div class="col-md-8">
<h2 style="color: #3771e3;">Labels</h2>
</div>
</div>
<div class="row">
<div class="col-md-8">
@ -116,22 +95,16 @@ title: 使用服务让您的应用程序外部可见
<br>
<div class="row">
<div class="col-md-8">
<p>Labels 可以在创建时或以后附加到对象，并可以随时修改。
在使用 kubectl run 命令新建 Pods/Deployment 时，会设置一些默认的 Labels/Label。标签和标签选择器之间的链接定义了 Deployment 及其创建 Pod 之间的关系。</p>
<p>现在，让我们在 Service 的帮助下公开我们的应用程序，并应用一些新的标签。</p>
<p>标签可以在创建时或之后附加到对象后，并支持随时修改。让我们现在开始使用服务公开我们的应用程序并应用一些标签吧。</p>
</div>
</div>
<br>
<div class="row">
<div class="col-md-12">
<a class="btn btn-lg btn-success" href="/docs/tutorials/kubernetes-basics/expose-interactive/" role="button">启动交互式教程<span class="btn__next">›</span></a>
<a class="btn btn-lg btn-success" href="/docs/tutorials/kubernetes-basics/expose-interactive/" role="button">启动互动教程<span class="btn__next">›</span></a>
</div>
</div>
</main>
</div>
</body>

10
cn/docs/tutorials/kubernetes-basics/index.html Executable file → Normal file
View File

@ -17,15 +17,15 @@ title: 概述
<div class="row">
<div class="col-md-9">
<h2>Kubernetes 基础</h2>
<p>本教程介绍了 Kubernetes 集群编排系统的基础知识。每个模块包含关于 Kubernetes 主要特性和概念的一些背景信息，并包括一个交互式在线教程。这些交互式教程让您可以自己管理一个简单的集群及其容器化应用程序。</p>
<p>使用交互式教程，您可以学习:</p>
<p>本教程介绍了 Kubernetes 集群编排系统的基础知识。每个模块包含关于 Kubernetes 主要特性和概念的一些背景信息，并包括一个在线互动教程。这些互动教程让您可以自己管理一个简单的集群及其容器化应用程序。</p>
<p>使用互动教程，您可以学习:</p>
<ul>
<li>在集群上部署容器化应用程序</li>
<li>弹性部署</li>
<li>使用新的软件版本，更新容器化应用程序</li>
<li>调试容器化应用程序</li>
</ul>
<p>教程 Katacoda 在您的浏览器中运行一个虚拟终端，在浏览器中运行 Minikube，这是一个可在任何地方小规模本地部署的 Kubernetes 集群。没有安装任何软件或进行任何配置; 每个交互性教程都直接从您的网页浏览器上运行。</p>
<p>教程 Katacoda 在您的浏览器中运行一个虚拟终端，在浏览器中运行 Minikube，这是一个可在任何地方小规模本地部署的 Kubernetes 集群。不需要安装任何软件或进行任何配置; 每个交互性教程都直接从您的网页浏览器上运行。</p>
</div>
</div>
@ -34,7 +34,7 @@ title: 概述
<div class="row">
<div class="col-md-9">
<h2>Kubernetes 可以为您做些什么?</h2>
<p>现代的 Web 服务，用户希望应用程序能够 24/7 全天候使用，开发人员希望每天可以多次发布部署新版本的应用程序。 容器化可以帮助软件包服务于这些目标，使应用程序能够以简单快速的方式发布和更新，而无需停机。Kubernetes 帮助您确保这些容器化的应用程序在您想要的地方和时间运行，并帮助应用程序找到它们需要的资源的工具。 <a href="http://kubernetes.io/docs/whatisk8s/">Kubernetes</a> 是一个生产可用的开源平台，具有 Google 容器集群方面的设计与经验积累，拥有来自社区的最佳实践。</p>
<p>通过现代的 Web 服务，用户希望应用程序能够 24/7 全天候使用，开发人员希望每天可以多次发布部署新版本的应用程序。 容器化可以帮助软件包达成这些目标，使应用程序能够以简单快速的方式发布和更新，而无需停机。Kubernetes 帮助您确保这些容器化的应用程序在您想要的时间和地点运行，并帮助应用程序找到它们需要的资源和工具。 <a href="http://kubernetes.io/docs/whatisk8s/">Kubernetes</a> 是一个可用于生产的开源平台，根据 Google 容器集群方面积累的经验，以及来自社区的最佳实践而设计。</p>
</div>
</div>
@ -77,7 +77,7 @@ title: 概述
<div class="thumbnail">
<a href="/docs/tutorials/kubernetes-basics/scale-intro/"><img src="./public/images/module_05.svg?v=1469803628347" alt=""></a>
<div class="caption">
<a href="scale-intro/"><h5>5. 应用可伸缩</h5></a>
<a href="scale-intro/"><h5>5. 应用可扩展</h5></a>
</div>
</div>
</div>

2
cn/docs/tutorials/kubernetes-basics/scale-interactive.html Executable file → Normal file
View File

@ -1,5 +1,5 @@
---
title: 交互式教程 - 扩展您的应用程序
title: 互动教程 - 扩展您的应用程序
---
<!DOCTYPE html>

13
cn/docs/tutorials/kubernetes-basics/scale-intro.html Executable file → Normal file
View File

@ -19,14 +19,15 @@ title: 运行应用程序的多个实例
<div class="col-md-8">
<h3>目标</h3>
<ul>
<li>使用 kubectl 缩放应用程序</li>
<li>使用 kubectl 伸缩应用程序</li>
</ul>
</div>
<div class="col-md-8">
<h3>缩放应用程序</h3>
<h3>应用程序伸缩</h3>
<p>在之前的模块中，我们创建了一个 <a href="http://kubernetes.io/docs/user-guide/deployments/"> Deployment</a>，然后通过 <a href="http://kubernetes.io/docs/user-guide/services/">Service</a>让应用程序外部可见。Deployment 仅为我们的应用程序创建了一个 Pod。 当流量增加时，我们将需要扩展应用程序以跟上用户需求。</p>
<p>在之前的模块中，我们创建了一个 <a href="http://kubernetes.io/docs/user-guide/deployments/"> Deployment</a>，然后通过 <a href="http://kubernetes.io/docs/user-guide/services/">Service</a>让应用程序外部可见。Deployment 仅为我们的应用程序创建了一个 Pod。 当流量增加时，我们将需要
应用程序以跟上用户需求。</p>
<p><b>Scaling</b> 是通过更改 Deployment 中的副本数量实现的。</p>
@ -35,7 +36,7 @@ title: 运行应用程序的多个实例
<div class="content__box content__box_lined">
<h3>摘要:</h3>
<ul>
<li>Deployment 的缩放</li>
<li>Deployment 的伸缩</li>
</ul>
</div>
<div class="content__box content__box_fill">
@ -101,14 +102,14 @@ title: 运行应用程序的多个实例
<div class="row">
<div class="col-md-8">
<p> 一旦您有应用程序的多个实例，您将能够滚动更新而不会停止服务。我们将在下一个模块中介绍。现在，我们去在线终端扩展我们的应用程序。</p>
<p> 一旦您有应用程序的多个实例，您将能够滚动更新，而不会停止服务————我们将在下一个模块中介绍这些。现在，我们去在线终端对我们的应用程序进行伸缩。</p>
</div>
</div>
<br>
<div class="row">
<div class="col-md-12">
<a class="btn btn-lg btn-success" href="/docs/tutorials/kubernetes-basics/scale-interactive/" role="button">启动交互式教程 <span class="btn__next">›</span></a>
<a class="btn btn-lg btn-success" href="/docs/tutorials/kubernetes-basics/scale-interactive/" role="button">启动互动教程 <span class="btn__next">›</span></a>
</div>
</div>

2
cn/docs/tutorials/kubernetes-basics/update-interactive.html Executable file → Normal file
View File

@ -1,5 +1,5 @@
---
title: 交互式教程 - 更新您的应用程序
title: 互动教程 - 更新您的应用程序
---
<!DOCTYPE html>

10
cn/docs/tutorials/kubernetes-basics/update-intro.html Executable file → Normal file
View File

@ -26,9 +26,9 @@ title: 执行滚动更新
<div class="col-md-8">
<h3>更新应用程序</h3>
<p>用户期望应用程序始终可用，并且开发人员有望每天部署新版本。这就是 Kubernetes 的滚动更新。 <b>Rolling updates</b> 允许通过使用新的 Pods 实例逐个更新来实现零停机的更新部署。新的 Pods 会被调度到可用资源的 Node 节点上。</p>
<p>用户期望应用程序始终可用，并且希望开发人员每天部署新版本。在 Kubernetes 上这通过滚动更新(Rolling updates)达成。 <b>Rolling updates</b> 允许通过使用新的 Pods 实例逐个更新来实现零停机的部署更新。新的 Pods 会被调度到可用资源的 Node 节点上。</p>
<p>在上一个模块中，我们将应用程序扩展为运行多个实例。这是执行更新但不影响应用可用性的要求。默认情况下，更新期间最大数量的 Pods 可能不可用，此时创建和更新 Pod 的最大数量是一。 这两个选项可以配置为数字或百分比(Pods)。
<p>在上一个模块中，我们将应用程序扩展为运行多个实例。这也是执行更新但不影响应用可用性所需的条件。默认情况下，更新期间最大数量的不可用 Pod 以及最大数量的新 Pod 是一。 这两个选项可以配置为数字或百分比(Pods)。
在 Kubernetes 中，更新已版本化，任何部署更新都可以恢复到以前的 (稳定) 版本。</p>
</div>
@ -94,13 +94,13 @@ title: 执行滚动更新
<div class="row">
<div class="col-md-8">
<p>与应用程序缩放类似，如果 Deployment 外部可见，则 Service 将在更新期间将流量负载均衡到可用的 Pod。可用的 Pod 指的是应用程序用户可用的实例。</p>
<p>与应用程序伸缩类似，如果 Deployment 外部可见，则服务将在更新期间将流量负载均衡到可用的 Pod。可用的 Pod 指的是应用程序用户可用的实例。</p>
<p>滚动更新允许以下操作:</p>
<ul>
<li>将应用程序从一个环境升级到另一个环境 (通过容器镜像更新)</li>
<li>回滚到以前的版本</li>
<li>持续集成和持续交付，实现应用程序零故障</li>
<li>持续集成和持续交付，实现应用程序零停机</li>
</ul>
@ -116,7 +116,7 @@ title: 执行滚动更新
<div class="row">
<div class="col-md-8">
<p> 在下面的交互式教程中，我们将把应用程序更新到一个新版本，并执行回滚。</p>
<p> 在下面的互动教程中，我们将把应用程序更新到一个新版本，并执行回滚。</p>
</div>
</div>
<br>

145
cn/docs/tutorials/object-management-kubectl/imperative-object-management-command.md Normal file
View File

@ -0,0 +1,145 @@
---
title: 使用命令式的方式管理 Kubernetes 对象
redirect_from:
- "/docs/concepts/tools/kubectl/object-management-using-imperative-commands/"
- "/docs/concepts/tools/kubectl/object-management-using-imperative-commands.html"
---
{% capture overview %}
直接使用内置的 `kubectl` 命令行工具，以命令式方式可以快速创建，更新和删除 Kubernetes 对象。本文档介绍了这些命令是如何组织的，以及如何使用它们来管理活动对象。
{% endcapture %}
{% capture body %}
## 权衡
`kubectl` 工具支持三种对象的管理:
* 命令式的方式
* 命令式的对象配置
* 声明式的对象配置
参见[Kubernetes对象管理](/docs/concepts/tools/kubectl/object-management-overview/)
讨论各种对象管理的优缺点.
## 如何创建对象
`kubectl` 工具支持用于创建一些最常用的对象类型的动词驱动命令，这些命令被命名为对于不熟悉的用户也是一目了然。
- `run`: 创建一个新的 Deployment 对象以在一个或多个 Pod 中运行 Containers。
- `expose`: 创建一个新的 Service 对象用于负载均衡 Pods 上的的网络流量。
- `autoscale`: 创建一个新的 Autoscaler 对象，即自动水平扩展控制器，提供 Deployment 自动水平伸缩支持。
`kubectl` 工具也支持由对象类型驱动的创建命令。 这些命令支持更多的对象类型，并且对其意图更为明确，但要求用户知道他们打算创建的对象的类型。
- `create <objecttype> [<subtype>] <instancename>`
某些对象类型具有您可以在“create"命令中指定的子类型.
例如，Service对象有几种子类型，包括ClusterIP，
LoadBalancer和NodePort. 以下是创建一个服务的示例
子类型NodePort:
一些对象类型允许你在 `create` 命令中指定子命令。例如，Service 对象拥有几个子命令，包括 ClusterIP、LoadBalancer 和 NodePort。以下是使用子命令 NodePort 创建服务的示例:
```shell
kubectl create service nodeport <myservicename>
```
在前面的例子中，调用 `create service nodeport`命令是 `create service`命令的子命令.
您可以使用 `-h` 标志来查找子命令支持的参数和标志:
```shell
kubectl create service nodeport -h
```
## 如何更新对象
`kubectl` 命令支持一些常见更新操作的动词驱动命令。这样命名可以让不熟悉 Kubernetes 对象的用户，在不知道必须设置的特定字段的情况下也可以执行更新操作:
- `scale`: 通过更新控制器的副本数量，水平扩展控制器以添加或删除 Pod。
- `annotate`: 从对象添加或删除注释。
- `label`: 为对象添加或删除标签。
`kubectl`命令还支持由对象的一个​​切面驱动的更新命令.设置此切面可能会为不同的对象类型设置不同的字段:
- `set` <field>: 设置对象的一个​​切面.
**注**: 在 Kubernetes 版本 1.5 中，并不是每个动词驱动的命令都有一个相关的切面驱动的命令.
`kubectl` 工具支持直接更新活动对象的其他方法，然而，它们需要更好的了解 Kubernetes 对象模式。
- `edit`: 通过在编辑器中打开其配置，直接编辑活动对象的原始配置。
- `patch`: 通过使用补丁字符串直接修改活动对象的特定字段。
有关补丁字符串的更多详细信息，请参阅补丁部分
[API 公约](https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#patch-operations).
## 如何删除对象
您可以使用 `delete` 命令从集群中删除一个对象:
- `delete <type>/<name>`
**注意**: 您可以对命令式命令和命令式对象配置都使用 `kubectl delete` 方法。两者的差异在于传递的命令参数不同。要将
`kubectl delete` 作为命令式命令使用，将要删除的对象作为参数传递。以下是传递名为 nginx 的 Deployment 对象的示例:
```shell
kubectl delete deployment/nginx
```
## 如何查看对象
{% comment %}
TODO(pwittrock): 实现时取消注释.
您可以使用 `kubectl view` 打印指定对象的字段。
- `view`: 打印对象的特定字段的值。
{% endcomment %}
有几个命令用于打印有关对象的信息:
- `get`: 打印有关匹配对象的基本信息。使用 `get -h` 来查看选项列表。
- `describe`: 打印有关匹配对象的聚合详细信息。
- `logs`: 打印 Pod 运行容器的 stdout 和 stderr 信息。
## 使用 `set` 命令在创建之前修改对象
有一些对象字段没有可以使用的标志，在 `create` 命令中。在某些情况下，您可以使用组合 `set` 和 `create` 为对象之前的字段指定一个值创建。这是通过将 `create` 命令的输出管道连接到 `set` 命令，然后回到 `create` 命令。以下是一个例子:
```sh
kubectl create service clusterip <myservicename> -o yaml --dry-run | kubectl set selector --local -f - 'environment=qa' -o yaml | kubectl create -f -
```
1. 使用 `create service -o yaml --dry-run` 创建服务配置，并将其作为 YAML 打印到 stdout，而不是将其发送到 Kubernetes API 服务器。
1. 使用 `set --local -f - -o yaml` 从 stdin 读取配置，并将更新后的配置作为 YAML 写入 stdout。
1. 使用 `kubectl create -f -` 从 stdin 提供的配置创建对象。
## 使用 `--edit` 在创建之前修改对象
您可以使用 `kubectl create --edit` 命令在对象创建之前，对对象进行任意更改。以下是一个例子:
```sh
kubectl create service clusterip my-svc -o yaml --dry-run > /tmp/srv.yaml
kubectl create --edit -f /tmp/srv.yaml
```
1. 使用`create service` 创建服务的配置并将其保存到 `/tmp/srv.yaml`。
1. 使用`create --edit` 在创建对象之前打开配置文件进行编辑。
{% endcapture %}
{% capture whatsnext %}
- [使用对象配置管理 Kubernetes 对象(必要)](/docs/tutorials/object-management-kubectl/imperative-object-management-configuration/)
- [使用对象配置(声明式)管理 Kubernetes 对象](/docs/tutorials/object-management-kubectl/declarative-object-management-configuration/)
- [Kubectl 命令参考](/docs/user-guide/kubectl/v1.6/)
- [Kubernetes 对象模式参考](/docs/resources-reference/v1.6/)
{% endcapture %}
{% include templates/concept.md %}

157
cn/docs/tutorials/object-management-kubectl/object-management.md Normal file
View File

@ -0,0 +1,157 @@
---
title: Kubernetes 对象管理
redirect_from:
- "/docs/concepts/tools/kubectl/object-management-overview/"
- "/docs/concepts/tools/kubectl/object-management-overview.html"
- "/docs/user-guide/working-with-resources/"
- "/docs/user-guide/working-with-resources.html"
---
{% capture overview %}
`kubectl` 命令行工具支持 Kubernetes 对象几种不同的创建和管理方法。本文档简要介绍了这些方法.
{% endcapture %}
{% capture body %}
## 管理技巧
**警告:** Kubernetes 对象应该只使用一种技术进行管理。混合使用不同的技术，会导致相同对象出现未定义的行为。
| 管理技术 | 操作 |推荐环境 | 支持撰写 | 学习曲线 |
|----------------------------------|----------------------|------------------------|--------------------|----------------|
| 命令式的方式 | 活动对象 | 开发项目 | 1+ | 最低 |
| 命令式对象配置 | 单文件 | 生产项目 | 1 | 中等 |
| 声明式对象配置 | 文件目录 | 生产项目 | 1+ | 最高 |
## 命令式的方式
当使用命令式的命令时，用户直接对集群中的活动对象进行操作。用户提供 `kubectl` 命令的参数或标记进行操作。
这是在集群中启动或运行一次性任务的最简单的方法。因为这种技术直接在活动对象上运行，所以它没有提供以前配置的历史记录。
### 例子
通过创建 Deployment 对象来运行 nginx 容器的实例:
```sh
kubectl run nginx --image nginx
```
使用不同的语法做同样的事情:
```sh
kubectl create deployment nginx --image nginx
```
### 权衡
与对象配置相比的优点:
- 命令简单易学，易于记忆。
- 命令只需要一个步骤即可对群集进行更改。
与对象配置相比的缺点:
- 命令不与变更审核流程整合。
- 命令不提供与更改相关联的审计跟踪。
- 除了活动对象之外，命令不提供记录来源。
- 命令不提供用于创建新对象的模板。
## 命令式对象配置
在命令式对象配置中，`kubectl` 命令指定操作(创建，替换等)，可选标志和至少一个文件名称。指定的文件必须包含对象的完整定义以 YAML 或 JSON 格式。
请参阅[参考资源](https://kubernetes.io/docs/resources-reference/v1.6/)
查看有关对象定义的更多细节。
**警告:** 命令式 `replace` 命令用新提供的命令替换现有资源规格，将对配置文件中缺少的对象的所有更改都丢弃。这种方法不应更新与配置文件无关的资源类型。例如，`LoadBalancer` 类型的服务使其 `externalIPs` 字段与集群的配置无关。
### 例子
创建对象定义配置文件:
```sh
kubectl create -f nginx.yaml
```
删除两个配置文件中定义的对象:
```sh
kubectl delete -f nginx.yaml -f redis.yaml
```
通过覆写实时配置更新配置文件中定义的对象:
```sh
kubectl replace -f nginx.yaml
```
### 权衡
与命令式的命令相比的优点:
- 对象配置可以存储在源码控制系统中，如Git。
- 对象配置可以与进程集成，例如在推送和审计跟踪之前查看更改。
- 对象配置提供了一个用于创建新对象的模板。
与命令式的命令相比的缺点:
- 对象配置需要对对象模式有基本的了解。
- 对象配置需要编写 YAML 文件的附加步骤。
与声明式对象配置相比的优势:
- 命令对象配置行为更简单易懂。
- 至于 Kubernetes 1.5 版本，命令式对象配置更为成熟。
与声明式对象配置相比的缺点:
- 命令对象配置最适合于文件，而不是目录。
- 活动对象的更新必须反映在配置文件中，否则在下次更替时将丢失。
## 声明式对象配置
当使用声明式对象配置时，用户对本地存储的对象配置文件进行操作，但是用户没有定义要对文件执行的操作。通过 `kubectl` 自动检测每个对象进行创建、更新和删除操作。这样可以在目录层级上工作，因为不同的对象可能需要不同的操作。
**注意:** 声明式对象配置保留由其他对象进行的更改，即使更改未合并到对象配置文件中。这可以通过使用 `patch` API 操作来写入观察到的差异，而不是使用`replace` API 操作来替换整个对象的配置。
### 例子
处理`configs` 目录中的所有对象配置文件，创建或修补(patch)活动对象:
```sh
kubectl apply -f configs/
```
递归处理目录:
```sh
kubectl apply -R -f configs/
```
### 权衡
与命令式对象配置相比的优点:
- 直接对活动对象进行的更改将被保留，即使它们未被并入到配置文件中。
- 声明式对象配置更好地支持目录操作，并自动检测每个对象的操作类型 (创建、修补，删除)。
与命令式对象配置相比的缺点:
- 声明式对象配置在意外情况下难以调试和了解结果。
- 使用差异的部分更新会创建复杂的合并和补丁操作。
{% endcapture %}
{% capture whatsnext %}
- [使用命令式的命令管理 Kubernetes 对象](/docs/tutorials/object-management-kubectl/imperative-object-management-command/)
- [使用对象配置管理 Kubernetes 对象(必要)](/docs/tutorials/object-management-kubectl/imperative-object-management-configuration/)
- [使用对象配置(声明式)管理 Kubernetes 对象](/docs/tutorials/object-management-kubectl/declarative-object-management-configuration/)
- [Kubectl 命令参考](/docs/user-guide/kubectl/v1.6/)
- [Kubernetes 对象模式参考](/docs/resources-reference/v1.6/)
{% comment %}
{% endcomment %}
{% endcapture %}
{% include templates/concept.md %}

1
cn/docs/whatisk8s.md
View File

@ -1,6 +1,7 @@
---
assignees:
- k8s-merge-robot
title: 认识 Kubernetes?
---