kubernetes 介绍_Kubernetes的友好介绍

kubernetes 介绍

Kubernetes is one of the most exciting technologies in the world of DevOps these days. It has attracted a lot of attention over the last few years. The reason for its instantaneous fame is the mighty containers.

如今，Kubernetes是DevOps世界上最令人兴奋的技术之一。 在过去的几年中，它吸引了很多关注。 它之所以成名的原因是强大的容器 。

Docker Inc. brought containers to the lime light with their impeccable marketing of an amazing product. Docker laid the foundation for the wide-spread use of containers, although container technology outdates it. Yet because of Docker, the use of Linux containers has become more prevalent, cementing the foundation for container orchestration engines.

Docker Inc.以无可挑剔的惊人产品营销方式引起了人们的关注。 Docker为容器的广泛使用奠定了基础，尽管容器技术已经过时了。 但是由于Docker，Linux容器的使用变得越来越普遍，这为容器编排引擎奠定了基础。

Enter Kubernetes — developed by Google using years of experience running a world class infrastructure on billions of containers. Kubernetes was an instant hit, and starting this year, Docker Inc. has packaged Kubernetes as an additional orchestration engine alongside Docker Swarm.

Enter Kubernetes –由Google开发，利用多年在数十亿个容器上运行世界一流基础设施的经验开发。 Kubernetes一炮走红，从今年开始，Docker Inc.已将Kubernetes与Docker Swarm打包在一起作为附加的编排引擎。

From now on, Kubernetes will be a part of the Docker community and Docker Enterprise Edition. Sounds pretty cool, huh? The best of both worlds packaged together as a single binary.

从现在开始，Kubernetes将成为Docker社区和Docker企业版的一部分。 听起来很酷吧？ 两全其美，打包成一个二进制文件。

鸟瞰概述 (Bird’s Eye Overview)

Kubernetes, k8s, or kube, is an open source platform that automates container operations. It eliminates most of the existing manual processes, which involve the deploying, scaling, and managing of containerized applications. Phew! thats a lot of work.

Kubernetes，k8s或kube是一个自动化容器操作的开源平台。 它消除了大多数现有的手动过程，这些过程涉及容器化应用程序的部署，扩展和管理。 ！ 那就是很多工作。

With Kubernetes, you can cluster groups of hosts running containers together. Kubernetes helps you manage those clusters. These clusters can span the public, private, and hybrid clouds — and who knows, the Star War universe one day.

使用Kubernetes，您可以将运行容器的主机组集群在一起。 Kubernetes可帮助您管理这些集群。 这些集群可以跨越公共云，私有云和混合云，而且有一天会知道《星际大战》的宇宙。

Kubernetes was developed and designed by the engineering team at Google. Google has long been a contributor to container technology. Alongside being vocal about its use of container technology, Kubernetes is the technology behind Google’s cloud service offerings.

Kubernetes是由Google的工程团队开发和设计的。 长期以来，Google一直是容器技术的贡献者。 除了吹嘘其使用容器技术外，Kubernetes是Google云服务产品背后的技术。

Google deploys more than 2 billion containers a week. All powered by an internal platform called Borg (sounds more like some Orc warlord from Mordor, but no). Borg was the predecessor to Kubernetes. The lessons learned by Google working with Borg over the years became the guiding force behind Kubernetes.

Google每周部署超过20亿个容器。 所有这些都由称为Borg的内部平台提供动力(听起来更像是Mordor的某些Orc军阀，但没有)。 博格是Kubernetes的前身。 多年来，Google与博格(Borg)合作所汲取的经验教训成为Kubernetes背后的指导力量。

Kubernetes makes everything associated with deploying and managing containerised applications a joy. Kubernetes automates rollouts, rollbacks, and monitors the health of deployed services. This prevents bad rollouts before things actually go bad.

Kubernetes使与部署和管理容器化应用程序相关的所有事情都倍感愉悦。 Kubernetes可以自动化部署，回滚并监视已部署服务的运行状况。 这样可以防止在实际情况恶化之前就推出糟糕的产品。

Additionally, Kubernetes can scale services up or down based on utilisation, ensuring you’re only running what you need, when you need it, wherever you need it. Like containers, Kubernetes allows us to manage clusters, enabling the setup to be version controlled and replicated.

此外，Kubernetes可以根据利用率来扩展或缩减服务，以确保您仅在需要时，无论何时何地运行所需的内容。 像容器一样，Kubernetes允许我们管理集群，从而可以对设置进行版本控制和复制。

This was a birds eye view, but don’t stop here. There’s more to Kubernetes than meets the eye (and that’s why I am writing this in the first place).

这是鸟瞰图，但不要在这里停下来。 Kubernetes所拥有的不仅仅是眼神(这就是为什么我首先写这篇文章的原因)。

Kubernetes如何工作？ (How does Kubernetes work?)

Kubernetes is a very complex system as compared to Docker’s orchestration solution, Docker Swarm. To understand how Kubernetes works, we need to understand its underlying concepts and principles.

与Docker的编排解决方案Docker Swarm相比，Kubernetes是一个非常复杂的系统。 要了解Kubernetes的工作原理，我们需要了解其基本概念和原理。

期望状态 (The Desired State)

Desired state is one of the core concepts of Kubernetes. You are free to define a state for the execution of containers inside Pods. If, due to some failure, the container stops running, Kubernetes recreates the Pod based on the lines of the desired state.

期望状态是Kubernetes的核心概念之一。 您可以自由定义Pods内部容器执行状态。 如果由于某种原因导致容器停止运行，Kubernetes将根据所需状态的行重新创建Pod。

Kubernetes strictly ensures that all the containers running across the cluster are always in the desired state. This is enforced by Kubernetes Master which is a part of the Kubernetes Control Plane. You can use the kubectl which interacts directly with the cluster to set or modify the desired state through the Kubernetes API.

Kubernetes严格确保跨集群运行的所有容器始终处于所需状态。 这是Kubernetes控制平面的一部分，由Kubernetes Master强制执行。 可以使用kubectl直接与簇相互作用以集合或通过Kubernetes API修改所需的状态。

Kubernetes对象 (Kubernetes Objects)

As defined in the Kubernetes Documentation:

根据Kubernetes文档中的定义：

A Kubernetes object is a “record of intent”–once you create the object, the Kubernetes system will constantly work to ensure that object exists. By creating an object, you’re effectively telling the Kubernetes system what you want your cluster’s workload to look like; this is your cluster’s desired state.

Kubernetes对象是“意图记录”-创建对象后，Kubernetes系统将不断工作以确保该对象存在。 通过创建一个对象，您可以有效地告诉Kubernetes系统您希望集群的工作负载是什么样子。 这是集群的理想状态。

The state of the entities in the system at any given point of time is represented by Kubernetes Objects. Kubernetes Objects also act as an additional layer of abstraction over the container interface. You can now directly interact with instances of Kubernetes Objects instead of interacting with containers. The basic Kubernetes objects are as follows:

Kubernetes对象表示任何给定时间点系统中实体的状态。 Kubernetes对象还充当容器接口上的附加抽象层。 您现在可以直接与Kubernetes对象的实例进行交互，而不必与容器进行交互。 基本的Kubernetes对象如下所示：

• Pod is the smallest deployable unit on a Node. It’s a group of containers which must run together. Quite often, but not necessarily, a Pod usually contains one container.

  荚 是Node上最小的可部署单元。 这是一组必须一起运行的容器。 Pod通常(但不一定)通常包含一个容器。

• Service is used to define a logical set of Pods and related policies used to access them.

  服务 用于定义Pod的逻辑集合 以及用于访问它们的相关策略。

• Volume is essentially a directory accessible to all containers running in a Pod.

  卷 本质上是一个在Pod中运行的所有容器均可访问的目录。

• Namespaces are virtual clusters backed by the physical cluster.

  命名空间 是由物理群集支持的虚拟群集。

There are a number of Controllers provided by Kubernetes. These Controllers are built upon the basic Kubernetes Objects and provide additional features. The Kubernetes Controllers include:

Kubernetes提供了许多控制器。 这些控制器基于基本的Kubernetes对象构建，并提供其他功能。 Kubernetes控制器包括：

• ReplicaSet ensures that a specified number of Pod replicas are running at any given time.

  复制集 确保在任何给定时间都运行指定数量的Pod副本。

• Deployment is used to change the current state to the desired state.

  部署用于将当前状态更改为所需状态。

• StatefulSet is used to ensure control over the deployment ordering and access to volumes, etc.

  有状态集 用于确保对部署顺序和对卷的访问等进行控制。

• DaemonSet is used to run a copy of a Pod on all the nodes of a cluster or on specified nodes.

  守护程序集 用于在群集的所有节点上或指定节点上运行Pod的副本。

• Job is used to perform some task and exit after successfully completing their work or after a given period of time.

  工作 用于执行某些任务，并在成功完成工作或给定时间后退出。

Kubernetes控制平面 (Kubernetes Control Plane)

The Kubernetes Control Plane works to make the cluster’s current state match your desired state. To do so, Kubernetes performs a variety of tasks automatically — for instance, starting or restarting containers, scaling the number of replicas of a given application, and much more.

Kubernetes控制平面可以使集群的当前状态与您所需的状态相匹配。 为此，Kubernetes自动执行各种任务，例如，启动或重新启动容器，扩展给定应用程序的副本数量等等。

As defined in the Kubernetes Documentation:

根据Kubernetes文档中的定义：

The various parts of the Kubernetes Control Plane, such as the Kubernetes Master and kubelet processes, govern how Kubernetes communicates with your cluster. The Control Plane maintains a record of all of the Kubernetes Objects in the system, and runs continuous control loops to manage the object’s state. At any given time, the Control Plane’s control loops will respond to changes in the cluster and work to make the actual state of all the objects in the system match the desired state that you defined.

Kubernetes控制平面的各个部分(例如Kubernetes Master和kubelet流程)控制Kubernetes如何与您的集群通信。 控制平面维护系统中所有Kubernetes对象的记录，并运行连续的控制循环以管理对象的状态。 在任何给定时间，控制平面的控制循环将响应群集中的更改，并努力使系统中所有对象的实际状态与您定义的所需状态相匹配。

The Kubernetes Control Plane performs the task of maintaining the desired state across the cluster. It records the object state and continuously runs a control loop to check if the current state of the object matches the desired state. You can think of it as the Government running the state.

Kubernetes控制平面执行维护整个集群所需状态的任务。 它记录对象状态并连续运行控制循环，以检查对象的当前状态是否与所需状态匹配。 您可以把它看作是政府治国的国家。

Kubernetes大师 (Kubernetes Master)

As a part of the Kubernetes Control Plane, the Kubernetes master works towards continuously maintaining the desired state throughout your cluster. The kubectl command is an interface to communicate with the cluster’s Kubernetes master through the Kubernetes API. Think of it as the police force responsible for maintaining law and order.

作为Kubernetes控制平面的一部分，Kubernetes主节点致力于在整个集群中持续保持所需的状态。 kubectl命令是用于通过Kubernetes API与集群的Kubernetes主服务器通信的接口。 可以将其视为负责维护治安的警察部队。

As defined in the Kubernetes Documentation:

根据Kubernetes文档中的定义：

The “master” refers to a collection of processes managing the cluster state. Typically these processes are all run on a single node in the cluster, and this node is also referred to as the master. The master can also be replicated for availability and redundancy.

“主”是指管理集群状态的进程的集合。 通常，这些进程都在集群中的单个节点上运行，并且该节点也称为主节点。 还可以复制主服务器以实现可用性和冗余。

The Kubernetes Master controls and coordinates all the nodes in the cluster with the help of three processes that run on one or more master nodes in the cluster. Each Kubernetes master in your cluster runs these three processes:

Kubernetes主节点借助在集群中一个或多个主节点上运行的三个进程来控制和协调集群中的所有节点。 集群中的每个Kubernetes主节点都运行以下三个过程：

1. kube-apiserver: the single point of management for the entire cluster. The API server implements a RESTful interface for communication with tools and libraries. The kubectl command directly interacts with the API server.

   kube-apiserver ：整个集群的单点管理。 API服务器实现了RESTful接口，用于与工具和库进行通信。 kubectl命令直接与API服务器进行交互。

2. kube-controller-manager: regulates the state of the cluster by managing the different kinds of controllers.

   kube-controller-manager ：通过管理不同种类的控制器来调节集群的状态。

3. kube-scheduler: schedules the workloads across the available nodes in the cluster.

   kube-scheduler ：计划集群中可用节点上的工作负载。

Kubernetes节点 (Kubernetes Nodes)

The Kubernetes nodes are basically worker machines (VMs, physical, bare metal servers, etc) in a cluster running your workloads. The nodes are controlled by Kubernetes master and are continuously monitored to maintain the desired state of the application. Previously they were known as minions (not the tiny hilarious yellow loyal army of Gru). Similar to the master, each Kubernetes node in your cluster runs two processes:

Kubernetes节点基本上是运行您的工作负载的集群中的工作机(VM，物理机，裸机服务器等)。 节点由Kubernetes主节点控制，并受到持续监视以维持应用程序的所需状态。 以前，他们被称为奴才 (不是格鲁(Gru)的一小撮热闹的黄色忠诚军团)。 与主服务器类似，集群中的每个Kubernetes节点都运行两个进程：

1. kubelet is a communication interface between the node and the Kubernetes Master.

   kubelet是节点和Kubernetes Master之间的通信接口。

2. kube-proxy is a network proxy that reflects services as defined in the Kubernetes API on each node. It can also perform simple TCP and UDP stream forwarding.

   kube-proxy是一个网络代理，可反映每个节点上的Kubernetes API中定义的服务。 它还可以执行简单的TCP和UDP流转发。

投票应用 (The Voting App)

Let’s get you up to speed by actually running an application on Kubernetes. But, before you can move a step further in the amazing world of Kubernetes, first you’ll need to install and run Kubernetes locally. So, let’s start with that. Skip this if you have Kubernetes and MiniKube installed.

让我们通过在Kubernetes上实际运行应用程序来加快速度。 但是，在进一步进入Kubernetes令人惊叹的世界之前，首先，您需要在本地安装和运行Kubernetes。 因此，让我们开始吧。 如果您已安装Kubernetes和MiniKube，请跳过此步骤。

安装Kubernetes (Installing Kubernetes)

Kubernetes now comes out of the box with Docker Community Edition for version 17.12.+. In case you don’t have the Community Edition installed, you can download it here.

Kubernetes现在随Docker Community Edition版本17.12。+开箱即用。 如果您没有安装Community Edition，则可以在此处下载。

安装MiniKube (Installing MiniKube)

To run Kubernetes locally you will need to install MiniKube. It creates a local VM and runs a single node cluster. Don’t even think of running your production cluster on it. It’s best used for development and testing purposes only.

要在本地运行Kubernetes，您将需要安装MiniKube 。 它创建一个本地VM并运行一个单节点群集。 甚至不要考虑在其上运行生产集群。 最好仅用于开发和测试目的。

单节点集群 (The Single Node Cluster)

To run a single node cluster, we just need to run the minikube start command. Voilà, a VM, a Cluster and Kubernetes are running.

要运行单节点集群，我们只需要运行minikube start命令。 Voilà，VM，集群和Kubernetes正在运行。

$ minikube start
Starting local Kubernetes v1.10.0 cluster...
Starting VM...
Getting VM IP address...
Moving files into cluster...
Setting up certs...
Connecting to cluster...
Setting up kubeconfig...
Starting cluster components...
Kubectl is now configured to use the cluster.
Loading cached images from config file.

To verify that your setup was successful, run kubectl version to check for the Kubernetes version running on your machine.

要验证安装是否成功，请运行kubectl version来检查计算机上运行的Kubernetes版本。

$ kubectl version
Client Version: version.Info{Major:"1", Minor:"9", GitVersion:"v1.9.1", GitCommit:"3a1c9449a956b6026f075fa3134ff92f7d55f812", GitTreeState:"clean", BuildDate:"2018-01-04T20:00:41Z", GoVersion:"go1.9.2", Compiler:"gc", Platform:"darwin/amd64"}
Server Version: version.Info{Major:"1", Minor:"10", GitVersion:"v1.10.0", GitCommit:"fc32d2f3698e36b93322a3465f63a14e9f0eaead", GitTreeState:"clean", BuildDate:"2018-03-26T16:44:10Z", GoVersion:"go1.9.3", Compiler:"gc", Platform:"linux/amd64"}

投票应用程序终于 (The Voting App Finally)

Fast forward to the Voting App now that you have installed Kubernetes on your local machine. This is a simple application based on micro-services architecture, consisting of 5 simple services.

现在，您已经在本地计算机上安装了Kubernetes，现在快进到投票应用程序。 这是一个基于微服务架构的简单应用程序，由5个简单服务组成。

1. Voting-App: Frontend of the application written in Python, used by users to cast their votes.

   Voting-App ：用Python编写的应用程序的前端，供用户用来投票。

2. Redis: In-memory database, used as intermediate storage.

   Redis ：内存数据库，用作中间存储。

3. Worker: .Net service, used to fetch votes from Redis and store in Postgres database.

   Worker ：.Net服务，用于从Redis获取投票并将其存储在Postgres数据库中。

4. DB: PostgreSQL database, used as database.

   DB ：PostgreSQL数据库，用作数据库。

5. Result-App: Frontend of the application written in Node.js, displays the voting results.

   Result-App ：用Node.js编写的应用程序的前端，显示投票结果。

Git clone and cd into the voting app repo.

Git clone并cd进入投票应用程序仓库。

dockersamples/example-voting-appexample-voting-app — Example Docker Compose appgithub.com

dockersamples / example-voting-app example-voting-app —示例Docker Compose应用程序 github.com

The folder “k8s-specifications” contains the Kubernetes yaml specifications of the Voting App’s services. For each service it has two yaml files: a service file and a deployment file. The service file defines a logical set of pods and the policies around them. Below is the resulting service file from the voting app.

文件夹“ k8s-specifications”包含投票应用程序服务的Kubernetes yaml规范。 对于每个服务，它都有两个Yaml文件：一个服务文件和一个部署文件。 服务文件定义了一组逻辑舱以及它们周围的策略。 以下是投票应用程序生成的服务文件。

apiVersion: v1
kind: Service
metadata:
  name: result
spec:
  type: NodePort
  ports:
  - name: "result-service"
    port: 5001
    targetPort: 80
    nodePort: 31001
  selector:
    app: result

A Deployment file is used to define the desired state of your application, such as the number of replicas that should be running at any given point of time. Below is the resulting deployment file from the voting app.

部署文件用于定义应用程序的所需状态，例如在任何给定时间点应运行的副本数。 以下是投票应用程序生成的部署文件。

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: result
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: result
    spec:
      containers:
      - image: dockersamples/examplevotingapp_result:before
        name: result

Time to create the service and deployment objects — piece of cake.

是时候创建服务和部署对象了。

$ kubectl create -f k8s-specifications/
deployment "db" created
service "db" created
deployment "redis" created
service "redis" created
deployment "result" created
service "result" created
deployment "vote" created
service "vote" created
deployment "worker" created

There you go! Your app has successfully been deployed to the single node cluster, and you can list the running pods and services.

你去！ 您的应用已成功部署到单节点群集，并且您可以列出正在运行的Pod和服务。

$ kubectl get pods
NAME                      READY     STATUS    RESTARTS   AGE
db-86b99d968f-s5pv7       1/1       Running   0          1m
redis-659469b86b-hrxqs    1/1       Running   0          1m
result-59f4f867b8-cthvc   1/1       Running   0          1m
vote-54f5f76b95-zgwrm     1/1       Running   0          1m
worker-56578c48f8-h7zvs   1/1       Running   0          1m
$ kubectl get svc
NAME         TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)          AGE
db           ClusterIP   10.109.241.59    <none>        5432/TCP         2m
kubernetes   ClusterIP   10.96.0.1        <none>        443/TCP          23m
redis        ClusterIP   10.102.242.148   <none>        6379/TCP         2m
result       NodePort    10.106.7.255     <none>        5001:31001/TCP   2m
vote         NodePort    10.103.28.96     <none>        5000:31000/TCP   2m

Behold the cats vs dogs war, which the cats always win. Cats are cute by design and their IDC attitude is a big win. But this is a discussion for another time.

看猫与狗的战争，猫总是赢。 猫在设计上很可爱，它们的IDC态度是一大胜利。 但这是另一次讨论。

Back to the moment, your voting app is exposed on port 30001, and the results app is exposed on port 31001. You can access it using localhost:port or, using the IP on which minikube is running, you can get that using minikube ip command.

回到现在，投票应用程序在端口30001上公开，结果应用程序在端口31001上公开。 您可以使用localhost：port来访问它，或者使用运行minikube的IP来访问它，可以使用minikube ip命令获取它。

Kubernetes备忘单 (Kubernetes Cheat Sheet)

Since you all have shown a lot of patience going through these blocks of text, let me now present to you the Kubernetes Cheat Sheet (which could have been a whole new article in itself, but whatever!):

既然大家对这些文本块都表现出了极大的耐心，那么现在让我向您介绍Kubernetes备忘单(它本来可以是一本全新的文章，但无论如何！)：

Minikube command:

Minikube命令：

# Start Minikube server
$ minikube start
# Get the Minikube IP
$ minikube ip

Version Info:

版本信息：

$ kubectl version             #Get kubectl version
$ kubectl cluster-info        #Get cluster info

Creating Objects:

创建对象：

$ kubectl create -f ./file.yml
$ kubectl create -f ./file1.yml -f ./file2.yaml
$ kubectl create -f ./dir
$ kubectl create -f http://www.fpaste.org/279276/48569091/raw/

Viewing and finding resources:

查看和查找资源：

# List all services in the namespace
$ kubectl get services
# List all pods in all namespaces
$ kubectl get pods --all-namespaces
# List all pods in the namespace, with more details   
$ kubectl get pods -o wide
# List a particular replication controller
$ kubectl get rc <rc-name>
# List all pods with a label env=production
$ kubectl get pods -l env=production

List services sorted by name:

列出按名称排序的服务：

$ kubectl get services --sort-by=.metadata.name

Modifying and Deleting resources:

修改和删除资源：

$ kubectl label pods <pod-name> new-label=awesome
$ kubectl annotate pods <pod-name> icon-url=http://goo.gl/XXBTWq
$ kubectl delete pod pingredis-XXXXX

Scaling up and down:

上下缩放：

$ kubectl scale --replicas=3 deployment nginx

Interacting with running Pods:

与运行中的Pod互动：

$ kubectl logs <pod-name>
# Runs a tailf log output
$ kubectl logs -f <pod-name>
# Run pod as interactive shell
$ kubectl run -i --tty busybox --image=busybox -- sh
# Attach to Running Container
$ kubectl attach <podname> -i
# Forward port of Pod to your local machine
$ kubectl port-forward <podname> <local-and-remote-port>
# Forward port to service
$ kubectl port-forward <servicename> <port>               
# Run command in existing pod (1 container case)
$ kubectl exec <pod-name> -- ls /
# Run command in existing pod (multi-container case)
$ kubectl exec <pod-name> -c <container-name> -- ls /

DNS Lookups:

DNS查询：

$ kubectl exec busybox -- nslookup kubernetes
$ kubectl exec busybox -- nslookup kubernetes.default
$ kubectl exec busybox -- nslookup kubernetes.default.svc.cluster.local

Create and expose a deployment:

创建并公开部署：

$ kubectl run nginx --image=nginx:1.9.12
$ kubectl expose deployment nginx --port=80 --type=LoadBalancer

摘要 (Summary)

Kubernetes is super exciting, cool, and most likely the future of container orchestration. The tech is great, and it is worth investing your time in if you are interested in containers or simply a fan like me. Kubernetes is a very powerful container orchestration engine, it can be used to amplify cloud containerisation strategy as it is designed to automate deploying, scaling, and operating containers.

Kubernetes非常令人兴奋，酷炫，而且很有可能是容器编排的未来。 这项技术很棒，如果您对容器感兴趣，或者只是像我这样的粉丝感兴趣，则值得您投入时间。 Kubernetes是一个非常强大的容器编排引擎，由于它旨在自动化容器的部署，扩展和操作，因此可用于放大云容器化策略。

The sunny side is that Kubernetes readily integrates with any cloud portfolio, be it public, private, hybrid or multi-cloud. Cloud vendors like AWS and Google provide managed Kubernetes services like Elastic Container Service for Kubernetes (EKS) and Google Kubernetes Engine (GKE). The dark side is that Kubernetes is significantly more complex than Docker’s very own container orchestration engine Docker Swarm.

乐观的一面是，Kubernetes可以轻松地与任何云产品组合集成，无论是公共，私有，混合还是多云。 像AWS和Google这样的云供应商提供托管的Kubernetes服务，例如Kubernetes的弹性容器服务(EKS)和Google Kubernetes Engine(GKE) 。 不利的一面是，Kubernetes比Docker自己的容器编排引擎Docker Swarm复杂得多。

All the information here was just for wetting your feet. If you feel like taking a dive in the awesome Kubernetes ocean, here you go.

这里的所有信息仅用于润湿您的脚。 如果您想在令人敬畏的Kubernetes海洋中潜水，那就去吧。

ramitsurana/awesome-kubernetesawesome-kubernetes - A curated list for awesome kubernetes sources :ship::tada:github.com

ramitsurana / awesome-kubernetes awesome-kubernetes-令人敬畏的kubernetes来源的精选清单：ship :: tada ： github.com

After you emerge from the deep dive, you might as well want to get hands on Kubernetes. Take Kubernetes for a ride or let it take you for one, in the Play with Kubernetes labs.

从深度学习中脱颖而出后，您不妨尝试使用Kubernetes。 在“与Kubernetes一起玩”的实验室中，乘坐Kubernetes乘车一路，或者带您一路走。

Play with KubernetesPlay with Kubernetes is a labs site provided by Docker and created by Tutorius. Play with Kubernetes is a playground…labs.play-with-k8s.com

使用Kubernetes 玩 Kubernetes 玩是由Docker提供并由Tutorius创建的实验室站点。 与Kubernetes一起玩是一个游乐场... labs.play-with-k8s.com

I hope this article helped in the understanding of Kubernetes. I’d love to hear about how you use Kubernetes in your projects. Clap if it increased your knowledge, and help it reach more people.

我希望本文有助于理解Kubernetes。 我很想听听您如何在项目中使用Kubernetes。 鼓掌，如果它能增加您的知识，并帮助它吸引更多的人。

翻译自: https://www.freecodecamp.org/news/a-friendly-introduction-to-kubernetes-670c50ce4542/

kubernetes 介绍