你的浏览器禁用了JavaScript, 请开启后刷新浏览器获得更好的体验!
文章由才云科技翻译，如若转载，必须注明转载自“才云科技”
今天我们来聊聊，但不从技术细节角度，聊为什么容器、Kubernetes是值得使用和整合到你的项目堆栈中的。我们的目标是给你们提供一个关于应该如何思考你的底层构架以及将它可视化问题，从这个角度来谈我们的话题：Kubernetes为什么重要？
Kubernetes的Root
为什么Kubernetes重要
－不同人员的任务角色
Kubernetes旨在作为你容器的管理层。然而，它的重点是无缝提供给你的应用程序真实实在的需要，满足你的应用程序所依赖的需要。举个例子，这些应用所需就是由Kubernetes提供的：访问与供应商无关的数据卷、负载均衡、冗余控制、弹性扩容、滚动更新以及配置密钥管理。
有了例如上述的性能和特点，再加上由Docker和容器本身运行时提供的打包件，管理应用程序的实践（不是servers）才开始通过使用Kubernetes展开。
Kubernetes的起源
Kubernetes的开始起源于谷歌，它在谷歌系统中有自己的起源：Borg和Omega。许多基于这些系统的设计和安装的相同概念，已经作为一个新的表现形式渗入Kubernetes，这个表现形式包括现今的标准，合并了很多谷歌在过去十年里吸取到的实践经验教训。
Kubernetes不是像很多人开场白讲得那样，是Borg或者Omega的“开源”版本；而是一个谷歌花了很多力气来为你的工作和服务创建的新管理工具。Kubernetes在谷歌是利用许多年的架构和实践经验开始的，但是因为它是开源项目，而且已经证明它可以真正简化开发、操作和管理职责，所以自从它的初始公开版本在2014年6月提交后，就积累了越来越多的代码提交贡献。
这是Kubernetes自从2015年以来收到的代码提交数量的一个截图：
这些图简短地描述了一个真实的、合作的Kubernetes技术社区。
就像我们之前提到过的，有很多人以个人名义或者是公司名义加入到Kubernentes。然而，真正的问题是，你有没有像最初开始的那样，按照谷歌的方式来运行你的应用程序和服务呢？
我们现在了解到的是，Kubernetes不仅仅只是一个容器管理系统，它也从内部查看了谷歌为实践每一个服务和产品：从Gmail、搜索、地图到GCE（服务产品清单还在持续增长），是如何运行他们的基础设施的。
因此，Kubernetes也是运行谷歌的一种方式，所以本质上来说，你注册就是为了能够访问一组指定的设计原则，这组原则会让你的应用程序有效运作，像谷歌那样轻松建立和管理您的应用程序。这并不是说，底层系统例如OpenStack或者AWS处理IaaS资源，就不能用了，而是说这些系统都尽可能做到最好，而Kubernetes就是为带来你的应用程序所需要的一切而生。最终，融合Kubernetes会创建一个良好组件的结合。
所以，如果你正在为你的项目考虑Kubernetes，那么你必须信任项目所呈现的基础和范式，从Pod开始，然后剩下的concepts自然会跟过来。这将给用户非凡的组合功能和灵活性，Kubernetes本身的视野在重新定义你的应用程序是如何构建的上体现了辅助作用。
Kubernetes为什么重要？
就像最近的关于Borg、Omega和Kubernetes的那篇论文里提到的细节（论文戳这里：Borg, Omega和Kubernetes：谷歌十几年来从这三个容器管理系统中得到的经验教训），Kubernetes帮助建立成套工具来辅助管理和缩放你的应用程序。
以下是Kubernetes如何让改进应用程序开发的方法：
容器将应用环境封装，从应用程序开发者和基础设施层面抽象掉很多机器和操作系统的细节。
管理API从面向机器转到面向应用程序，程序部署和检查极大提高，数据中心也由面向机器转向面向应用程序。
应用程序API的转换可以让团队无需担心机器和操作系统的细节特性。
专注于机器上的应用程序，这也允许团队以更灵活、更模块化的方式来操作。
原因是Kubrnetes是pod的常见使用模式实例，或者说是一个组件，是一个复杂应用程序中可以编写，运行以及被一个小团队全权负责管理功能的组件。
甚至其它的Kubernetes旨在提高你的应用程序的组件，是建立在例如像ReplicationsSets，部署，服务之类的概念之上，因此，合并巩固所有的应用程序需求，业务政策以及团队，就变得简单，可以无缝衔接。你可以探测不同的Kubernetes的概念，不仅仅跟Pod互相作用，而且允许你为你的应用在《用户指南词汇表》里创建新功能。
不同人员的任务角色：
Kubernetes也会通过吸引大量不同的任务角色来给你的公司构架提供帮助。
开发者（developers）：不仅可以创建通用的应用，他们还可以使用集群本质的属性来完成任何应用的特定需求。
在使用案例之中，devs想要把一个特定的Node作为目标，或者将一组Nodes作为目标，表示不同的硬件细节的特定标签可以用于个人Pod调度。也就是，如果你想要在AMD CPU（而不是Intel）架构上运行你的应用程序，或者你希望利用GPU，甚至是有大数量的RAM的Node。
消耗各种不同的机器在不仅在Kubernetes上是可能的，而且它事实上将所有的机器都拉平衡，并且将他们呈现为一个通用的计算资源。
这不仅由你的应用程序体现了Pets vs. Cattle的意识形态，你的机器也是。
运维（Devops）：Kubernetes概念，比如像Deployments，replicaSets，Services等等，所有这些都会帮助减轻运维，确保每个应用都有一个描述性的系列业务政策，而且这些规格都是随时实施和维护的。
管理员（Admins）：作为Kubernetes的一部分，admins可以通过使用例如像Heapster或者cAdvisor一样的工具来获得访问权和流程容器资源，同样的，检查集群的事件，API请求，监测数据，和利用Kubedash做分析。
这些不同的软件度量不仅提供检测Kubernetes集群服务，而且还提供一个对这些应用程序自身的细粒度理解，因为他们都是单独控制的。如果不把一些复杂沉重的安装留给用户的话，很多在其他系统里的应用程序层面的分析是不可能完成的。这些在Kubernetes上的本地功能说明了项目的努力不仅是针对你的应用程序的增长，而且这个水准的信息是一个为你的应用程序确定的需求，你不该自己创建这个功能，而是该功能应该被通过系统提交给你。
其他：最近，许多不同的任务角色可以跟Kubernetes互相作用，在基础水准上，通过利用dashboard将你的集群可视化，同时运行措施：比如创建一个新的资源，比如为对资源利用标签进行查询，比如检查或生成报告。
为了帮助大家理解Kubernetes大框架是如何运作，我们来展示的一些图，可以帮助大家更好的理解这个项目。
就像James Burker说的：
只有你知道自己去过哪里，你才会知道你想去往哪里
基于这个话，我们要考虑Kubernetes的鼻祖就是Borg以及它和Borg的极大渊源。从这句话出发，我们可以考虑该如何有组织的思考集群。
让我们先来看一些从Borg的论文里读到的情况，这不仅可以让我们一窥Borg是如何配置的，还可以让我们知道同样的模型是如何应用到Kubernetes上面的。
这里我们可以看到我们的首要云架构从上面看是怎么样的。
如果我们进一步放大，我们可以检测到每个在数据中心的建设包括了至少一个Borg集群，它被分成了约10000个机器：
再进一步观察这个“细胞”，我们可以一睹控制台的组件和工人／Nodes的不同，以及Kubernetes Pods和Borg里十分相像，对于任何应用程序后者在整个过程中的服务，是唯一的原子单元。
可能就像你现在注意到的那样，这里有很多平行的Borg组件，还有现在存在于Kubernetes之中的，特别是1:1相对应的集群和Pods——这些相似点会让你在思考联合Kubernetes配置的时候更快想明白。
虽然Kubernetes目前还不能像Borg那样每个集群规模达到10000个节点，但是它最近已经优化到可以允许集群支持最多1000个Nodes和30000个pods，而且99%的API可以在1秒内呼叫回应，还有99%的Pods（已经有先拉下来的镜像）在5秒内开启——巨额收益代表规模增长10倍，据报道称根据谷歌的内部人士称，实际是增长将近14倍。
Kubernetes当然是为“黄金时间段”准备的，不仅是因为许多公司都在生产过程中使用，而且还单纯因为它的性能和规模。
我们希望你能够有更好的理解在现今的软件发展时代“Kubernents为什么重要”的原因，也希望你能够更好理解如何组织以及构架你的集群来使之整合。
去接受Kubernetes的规范，可能一开始看起来像是消防水龙带但本质上是深思熟虑之后的设计原则，这原则不仅为软件开发展示适当的方法考虑，还为每一个从ops到管理系统的不论重要还是辅助的应用程序组件都考虑到了。
重复一遍，文章由才云科技翻译，如若转载，必须注明转载自“才云科技”
想要了解更多关于Kubernetes的信息，欢迎关注Caicloud公众平台
用Kubernetes 还是 docker Swarm, 好纠结...
要回复文章请先或docker（7）
此文档为本人搭建过程中记录，基本按照文档来。都能够搭建出自己的k8s集群，如果按照文档还不能解决问题，那么可以通过进行交流。
集群环境部署
kube-apiserver\kube-controller-manager\kube-scheduler
kube-proxy\kubelet
master:10.1.0.71
node1:10.1.0.78
node2:10.1.0.74(后续增加node)
**由于部署过程中需要声明环境变量及生成一系列证书文件，建议大家找一个部署工作目录，笔者此套部署集群的工作目录为/home/k8s-1.6/file（自行创建）**
定义环境变量
cat /home/k8s-1.6/file/environment.sh
export BOOTSTRAP_TOKEN="d869eebff"
export SERVICE_CIDR="10.254.0.0/16"
export CLUSTER_CIDR="172.30.0.0/16"
export NODE_PORT_RANGE=""
export ETCD_ENDPOINTS="https://10.1.0.71:2379,https://10.1.0.78:2379"
export FLANNEL_ETCD_PREFIX="/kubernetes/network"
export CLUSTER_KUBERNETES_SVC_IP="10.254.0.1"
export CLUSTER_DNS_SVC_IP="10.254.0.2"
export CLUSTER_DNS_DOMAIN="cluster.local."
export NODE_NAME=etcd-host0
export NODE_IP=10.1.0.71
export NODE_IPS="10.1.0.71 10.1.0.78"
export ETCD_NODES=etcd-host0=https://10.1.0.71:2380,etcd-host1=https://10.1.0.78:2380
export MASTER_IP=10.1.0.71
export KUBE_APISERVER="https://${MASTER_IP}:6443"
执行文件使环境变量生效
source /home/k8s-1.6/file/environment.sh
制造TSL证书
kubernetes 系统各组件需要使用 TLS 证书对通信进行加密，本文档使用 CloudFlare 的 PKI 工具集 cfssl 来生成 Certificate Authority (CA) 证书和秘钥文件，CA 是自签名的证书，用来签名后续创建的其它 TLS 证书。
$ wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64
$ chmod +x cfssl_linux-amd64
$ sudo mv cfssl_linux-amd64 /bin/cfssl
$ wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64
$ chmod +x cfssljson_linux-amd64
$ sudo mv cfssljson_linux-amd64 /bin/cfssljson
$ wget https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64
$ chmod +x cfssl-certinfo_linux-amd64
$ sudo mv cfssl-certinfo_linux-amd64 /bin/cfssl-certinfo
$ cfssl print-defaults config & config.json
$ cfssl print-defaults csr & csr.json
集群搭建中可以先在master上生成所有证书，然后再将node需要的证书拷贝过去，集群中所需要的证书：（具体证书生成内容及步骤在后面体现）
[root@LOC-XAN-PRO-032 ssl]# ll *.pem
-rw------- 1 root root 1679 8月
9 19:15 admin-key.pem
-rw-r--r-- 1 root root 1399 8月
9 19:15 admin.pem
-rw------- 1 root root 1675 8月
9 17:21 ca-key.pem
-rw-r--r-- 1 root root 1359 8月
9 17:21 ca.pem
-rw------- 1 root root 1675 8月
9 19:12 etcd-key.pem
-rw-r--r-- 1 root root 1436 8月
9 19:12 etcd.pem
-rw------- 1 root root 1679 8月
9 19:22 flanneld-key.pem
-rw-r--r-- 1 root root 1391 8月
9 19:22 flanneld.pem
-rw------- 1 root root 1675 8月
10 10:10 harbor-key.pem
-rw-r--r-- 1 root root 1419 8月
10 10:10 harbor.pem
-rw------- 1 root root 1675 8月
9 20:11 kube-proxy-key.pem
-rw-r--r-- 1 root root 1403 8月
9 20:11 kube-proxy.pem
-rw------- 1 root root 1679 8月
9 19:41 kubernetes-key.pem
-rw-r--r-- 1 root root 1627 8月
9 19:41 kubernetes.pem
生成ca证书和密钥
$ cat & ca-config.json &&EOF
"signing": {
"default": {
"expiry": "8760h"
"profiles": {
"kubernetes": {
"usages": [
"signing",
"key encipherment",
"server auth",
"client auth"
"expiry": "8760h"
$ cat & ca-csr.json &&EOF
"CN": "kubernetes",
"algo": "rsa",
"size": 2048
"names": [
"C": "CN",
"ST": "BeiJing",
"L": "BeiJing",
"O": "k8s",
"OU": "System"
$ cfssl gencert -initca ca-csr.json | cfssljson -bare ca
ca-config.json
ca-csr.json
ca-key.pem
将生成的 CA 证书、秘钥文件、配置文件拷贝到所有机器的 /etc/kubernetes/ssl 目录下
$ sudo mkdir -p /etc/kubernetes/ssl
$ sudo cp ca* /etc/kubernetes/ssl
kuberntes 系统使用 etcd 存储所有数据，笔者部署一个双节点高可用 etcd 集群的步骤，这两个节点复用 kubernetes master 机器，分别命名为etcd-host0、etcd-host1：
etcd-host0：10.1.0.71
etcd-host1：10.1.0.78
下载etcd二进制文件
$ wget https:
$ tar -xvf etcd-v3.1.6-linux-amd64.tar.gz
$ sudo mv etcd-v3.1.6-linux-amd64/etcd* /bin
生成etcd证书和私钥
$ cat & etcd-csr.json &&EOF
"CN": "etcd",
"hosts": [
"127.0.0.1",
"10.1.0.71",
"10.1.0.78"
"algo": "rsa",
"size": 2048
"names": [
"C": "CN",
"ST": "BeiJing",
"L": "BeiJing",
"O": "k8s",
"OU": "System"
**#需要注意的是在写etcd-csr.json时，hosts内容需要包含集群的ip**。
$ cfssl gencert -ca=./ca.pem -ca-key=./ca-key.pem -config=./ca-config.json -profile=kubernetes etcd-csr.json | cfssljson -bare etcd
$ ls etcd*
etcd-csr.json
etcd-key.pem etcd.pem
$ sudo mkdir -p /etc/etcd/ssl
$ sudo cp etcd*.pem /etc/etcd/ssl
将生成的etcd证书和密钥文件拷贝到etcd集群的各个机器的/etc/etcd/ssl目录下
$ sudo mkdir -p /etc/etcd/ssl
$ sudo cp etcd*.pem /etc/etcd/ssl
创建etcd.service服务
$ sudo mkdir -p /var/lib/etcd
**# 必须先创建工作目录**
$ cat & etcd.service &&EOF
Description=Etcd Server
After=network.target
After=network-online.target
Wants=network-online.target
Documentation=/coreos
Type=notify
WorkingDirectory=/var/lib/etcd/
ExecStart=/bin/etcd \\
--name=${NODE_NAME} \\
--cert-file=/etc/etcd/ssl/etcd.pem \\
--key-file=/etc/etcd/ssl/etcd-key.pem \\
--peer-cert-file=/etc/etcd/ssl/etcd.pem \\
--peer-key-file=/etc/etcd/ssl/etcd-key.pem \\
--trusted-ca-file=/etc/kubernetes/ssl/ca.pem \\
--peer-trusted-ca-file=/etc/kubernetes/ssl/ca.pem \\
--initial-advertise-peer-urls=https://${NODE_IP}:2380 \\
--listen-peer-urls=https://${NODE_IP}:2380 \\
--listen-client-urls=https://${NODE_IP}:2379,http://127.0.0.1:2379 \\
--advertise-client-urls=https://${NODE_IP}:2379 \\
--initial-cluster-token=etcd-cluster-0 \\
--initial-cluster=${ETCD_NODES} \\
--initial-cluster-state=new \\
--data-dir=/var/lib/etcd
Restart=on-failure
RestartSec=5
LimitNOFILE=65536
WantedBy=multi-user.target
**#需要注意的是，要先启动master下etcd服务，再启动node上的etcd服务，否则会有报错。
#一般存在报错时，检查环境变量的NODE_NAME、NODE_IP以及/var/lib/etcd是否存在。**
启动etcd服务
$ sudo mv etcd.service /etc/systemd/system/
$ sudo systemctl daemon-reload
$ sudo systemctl enable etcd
$ sudo systemctl start etcd
$ systemctl status etcd
验证etcd服务
for ip in ${NODE_IPS}; do
ETCDCTL_API=3 /bin/etcdctl \
--endpoints=https://${ip}:2379
--cacert=/etc/kubernetes/ssl/ca.pem \
--cert=/etc/etcd/ssl/etcd.pem \
--key=/etc/etcd/ssl/etcd-key.pem \
17:58:15.954431 I | warning: ignoring ServerName for user-provided CA for backwards compatibility is deprecated
https://10.1.0.71:2379 is healthy: successfully committed proposal: took = 2.9803ms
17:58:16.043153 I | warning: ignoring ServerName for user-provided CA for backwards compatibility is deprecated
https://10.1.0.78:2379 is healthy: successfully committed proposal: took = 3.154291ms
部署kubectl
下载kubectl
$ wget https://dl.k8s.io/v1.6.2/kubernetes-client-linux-amd64.tar.gz
$ tar -xzvf kubernetes-client-linux-amd64.tar.gz
$ sudo cp kubernetes/client/bin/kube* /bin/
$ chmod a+x /bin/kube*
#生成damin证书
$ cat & admin-csr.json &&EOF
"CN": "admin",
"hosts": [],
"algo": "rsa",
"size": 2048
"names": [
"C": "CN",
"ST": "BeiJing",
"L": "BeiJing",
"O": "system:masters",
"OU": "System"
$ cfssl gencert -ca=./ca.pem -ca-key=./ca-key.pem -config=./ca-config.json -profile=kubernetes admin-csr.json | cfssljson -bare admin
$ ls admin*
admin-csr.json
admin-key.pem
将生成好的admin*.pem证书拷贝到集群节点/etc/kubernetes/ssl下
$ sudo cp admin*.pem /etc/kubernetes/ssl/
创建 kubectl kubeconfig 文件
$ **# 设置集群参数**
$ kubectl config set-cluster kubernetes \
--certificate-authority=/etc/kubernetes/ssl/ca.pem \
--embed-certs=true \
--server=${KUBE_APISERVER}
$ **# 设置客户端认证参数**
$ kubectl config set-credentials admin \
--client-certificate=/etc/kubernetes/ssl/admin.pem \
--embed-certs=true \
--client-key=/etc/kubernetes/ssl/admin-key.pem
$ **# 设置上下文参数**
$ kubectl config set-context kubernetes \
--cluster=kubernetes \
--user=admin
$ **# 设置默认上下文**
$ kubectl config use-context kubernetes
**#分发 kubeconfig 文件：将 ~/.kube/config 文件拷贝到运行 kubelet 命令的机器的 ~/.kube/ 目录下。**
部署flanneld集群
kubernetes 要求集群内各节点能通过 Pod 网段互联互通，需要在所有节点 (Master、Node) 上创建互联互通的 Pod 网段
生成flanneld证书
$ cat & flanneld-csr.json &&EOF
"CN": "flanneld",
"hosts": [],
"algo": "rsa",
"size": 2048
"names": [
"C": "CN",
"ST": "BeiJing",
"L": "BeiJing",
"O": "k8s",
"OU": "System"
$ cfssl gencert -ca=./ca.pem -ca-key=./ca-key.pem -config=./ca-config.json -profile=kubernetes flanneld-csr.json | cfssljson -bare flanneld
$ ls flanneld*
flanneld.csr
flanneld-csr.json
flanneld-key.pem flanneld.pem
将生成的flanneld*.pem证书拷贝到集群节点/etc/flanneld/ssl下
$ sudo mkdir -p /etc/flanneld/ssl
$ sudo cp flanneld*.pem /etc/flanneld/ssl
向 etcd 写入集群 Pod 网段信息（本步骤只需在第一次部署 Flannel 网络时执行，后续在其它节点上部署 Flannel 时无需再写入该信息！）
$ /bin/etcdctl \
--endpoints=${ETCD_ENDPOINTS} \
--ca-file=/etc/kubernetes/ssl/ca.pem \
--cert-file=/etc/flanneld/ssl/flanneld.pem \
--key-file=/etc/flanneld/ssl/flanneld-key.pem \
set ${FLANNEL_ETCD_PREFIX}/config '{"Network":"'${CLUSTER_CIDR}'", "SubnetLen": 24, "Backend": {"Type": "vxlan"}}'
下载安装flanneld
$ wget https://github.com/coreos/flannel/releases/download/v0.7.1/flannel-v0.7.1-linux-amd64.tar.gz
$ tar -xzvf flannel-v0.7.1-linux-amd64.tar.gz
$ sudo cp ./{flanneld,mk-docker-opts.sh} /bin
创建 flanneld 的 systemd unit 文件
$ cat & flanneld.service && EOF
Description=Flanneld overlay address etcd agent
After=network.target
After=network-online.target
Wants=network-online.target
After=etcd.service
Before=docker.service
Type=notify
ExecStart=/bin/flanneld \\
-etcd-cafile=/etc/kubernetes/ssl/ca.pem \\
-etcd-certfile=/etc/flanneld/ssl/flanneld.pem \\
-etcd-keyfile=/etc/flanneld/ssl/flanneld-key.pem \\
-etcd-endpoints=${ETCD_ENDPOINTS} \\
-etcd-prefix=${FLANNEL_ETCD_PREFIX}
ExecStartPost=/bin/mk-docker-opts.sh -k DOCKER_NETWORK_OPTIONS -d /run/flannel/docker
Restart=on-failure
WantedBy=multi-user.target
RequiredBy=docker.service
$ sudo mv flanneld.service /etc/systemd/system/
$ sudo systemctl daemon-reload
$ sudo systemctl enable flanneld
$ sudo systemctl start flanneld
$ systemctl status flanneld
$ journalctl
-u flanneld |grep 'Lease acquired'
Nov 07 17:53:37 LOC-XAN-TEST-071 flanneld[43520]: I1107 17:53:37.228939
43520 manager.go:250] Lease acquired: 172.30.16.0/24
Nov 07 17:56:24 LOC-XAN-TEST-071 flanneld[43732]: I1107 17:56:24.061383
43732 manager.go:250] Lease acquired: 172.30.16.0/24
检查分配给各 flanneld 的 Pod 网段信息
$ /bin/etcdctl \
--endpoints=${ETCD_ENDPOINTS} \
--ca-file=/etc/kubernetes/ssl/ca.pem \
--cert-file=/etc/flanneld/ssl/flanneld.pem \
--key-file=/etc/flanneld/ssl/flanneld-key.pem \
get ${FLANNEL_ETCD_PREFIX}/config
2017-11-07 18:01:16.414771 I | warning: ignoring ServerName for user-provided CA for backwards compatibility is deprecated
$ /bin/etcdctl \
--endpoints=${ETCD_ENDPOINTS} \
--ca-file=/etc/kubernetes/ssl/ca.pem \
--cert-file=/etc/flanneld/ssl/flanneld.pem \
--key-file=/etc/flanneld/ssl/flanneld-key.pem \
ls ${FLANNEL_ETCD_PREFIX}/subnets
2017-11-07 18:02:01.873705 I | warning: ignoring ServerName for user-provided CA for backwards compatibility is deprecated
$ /bin/etcdctl \
--endpoints=${ETCD_ENDPOINTS} \
--ca-file=/etc/kubernetes/ssl/ca.pem \
--cert-file=/etc/flanneld/ssl/flanneld.pem \
--key-file=/etc/flanneld/ssl/flanneld-key.pem \
get ${FLANNEL_ETCD_PREFIX}/subnets/172.30.16.0-24
2017-11-07 18:02:50.694103 I | warning: ignoring ServerName for user-provided CA for backwards compatibility is deprecated
{"PublicIP":"10.1.0.71","BackendType":"vxlan","BackendData":{"VtepMAC":"be:3f:33:a0:15:b9"}}
部署master节点
kubernetes master 节点包含的组件：
kube-apiserver
kube-scheduler
kube-controller-manager
$ wget /kubernetes/kubernetes/releases/download/v1.6.2/kubernetes.tar.gz
$ tar -xzvf kubernetes.tar.gz
$ cd kubernetes
$ ./cluster/get-kube-binaries.sh
$ wget https://dl.k8s.io/v1.6.2/kubernetes-server-linux-amd64.tar.gz
$ tar -xzvf kubernetes-server-linux-amd64.tar.gz
$ cd kubernetes
$ tar -xzvf
kubernetes-src.tar.gz
$ sudo cp -r server/bin/{kube-apiserver,kube-controller-manager,kube-scheduler,kubectl,kube-proxy,kubelet} /bin/
生成kubernetes证书
$ cat & kubernetes-csr.json &&EOF
"CN": "kubernetes",
"hosts": [
"127.0.0.1",
"${MASTER_IP}",
"${CLUSTER_KUBERNETES_SVC_IP}",
"kubernetes",
"kubernetes.default",
"kubernetes.default.svc",
"kubernetes.default.svc.cluster",
"kubernetes.default.svc.cluster.local"
"algo": "rsa",
"size": 2048
"names": [
"C": "CN",
"ST": "BeiJing",
"L": "BeiJing",
"O": "k8s",
"OU": "System"
**#需要注意的是hosts字段内容：（当多master节点时，hosts字段应该列出对应的ip列表）**
$ cfssl gencert -ca=./ca.pem -ca-key=./ca-key.pem -config=./ca-config.json -profile=kubernetes kubernetes-csr.json | cfssljson -bare kubernetes
$ ls kubernetes*
kubernetes.csr
kubernetes-csr.json
kubernetes-key.pem
kubernetes.pem
将实现生成的kubernetes*.pem拷贝到节点/etc/kubernetes/ssl下
$ sudo cp kubernetes*.pem /etc/kubernetes/ssl/
创建 kube-apiserver 使用的客户端 token 文件
kubelet 首次启动时向 kube-apiserver 发送 TLS Bootstrapping 请求，kube-apiserver 验证 kubelet 请求中的 token 是否与它配置的 token.csv 一致，如果一致则自动为 kubelet生成证书和秘钥。
$ cat & token.csv &&EOF
${BOOTSTRAP_TOKEN},kubelet-bootstrap,10001,"system:kubelet-bootstrap"
$ cp token.csv /etc/kubernetes/
创建 kube-apiserver 的 systemd unit 文件
& kube-apiserver.service &&EOF
Description=Kubernetes API Server
Documentation=/GoogleCloudPlatform/kubernetes
After=network.target
ExecStart=/bin/kube-apiserver \\
--admission-control=NamespaceLifecycle,LimitRanger,ServiceAccount,DefaultStorageClass,ResourceQuota \\
--advertise-address=${MASTER_IP} \\
--bind-address=${MASTER_IP} \\
--insecure-bind-address=${MASTER_IP} \\
--authorization-mode=RBAC \\
--runtime-config=rbac.authorization.k8s.io/v1alpha1 \\
--kubelet-https=true \\
--experimental-bootstrap-token-auth \\
--token-auth-file=/etc/kubernetes/token.csv \\
--service-cluster-ip-range=${SERVICE_CIDR} \\
--service-node-port-range=${NODE_PORT_RANGE} \\
--tls-cert-file=/etc/kubernetes/ssl/kubernetes.pem \\
--tls-private-key-file=/etc/kubernetes/ssl/kubernetes-key.pem \\
--client-ca-file=/etc/kubernetes/ssl/ca.pem \\
--service-account-key-file=/etc/kubernetes/ssl/ca-key.pem \\
--etcd-cafile=/etc/kubernetes/ssl/ca.pem \\
--etcd-certfile=/etc/kubernetes/ssl/kubernetes.pem \\
--etcd-keyfile=/etc/kubernetes/ssl/kubernetes-key.pem \\
--etcd-servers=${ETCD_ENDPOINTS} \\
--enable-swagger-ui=true \\
--allow-privileged=true \\
--apiserver-count=3 \\
--audit-log-maxage=30 \\
--audit-log-maxbackup=3 \\
--audit-log-maxsize=100 \\
--audit-log-path=/var/lib/audit.log \\
--event-ttl=1h \\
Restart=on-failure
RestartSec=5
Type=notify
LimitNOFILE=65536
WantedBy=multi-user.target
启动kube-apiserver服务
$ sudo cp kube-apiserver.service /etc/systemd/system/
$ sudo systemctl daemon-reload
$ sudo systemctl enable kube-apiserver
$ sudo systemctl start kube-apiserver
$ sudo systemctl status kube-apiserver
创建 kube-controller-manager 的 systemd unit 文件
$ cat & kube-controller-manager.service &&EOF
Description=Kubernetes Controller Manager
Documentation=/GoogleCloudPlatform/kubernetes
ExecStart=/bin/kube-controller-manager \\
--address=127.0.0.1 \\
--master=http://${MASTER_IP}:8080 \\
--allocate-node-cidrs=true \\
--service-cluster-ip-range=${SERVICE_CIDR} \\
--cluster-cidr=${CLUSTER_CIDR} \\
--cluster-name=kubernetes \\
--cluster-signing-cert-file=/etc/kubernetes/ssl/ca.pem \\
--cluster-signing-key-file=/etc/kubernetes/ssl/ca-key.pem \\
--service-account-private-key-file=/etc/kubernetes/ssl/ca-key.pem \\
--root-ca-file=/etc/kubernetes/ssl/ca.pem \\
--leader-elect=true \\
Restart=on-failure
RestartSec=5
WantedBy=multi-user.target
启动kube-controller-manager服务
$ sudo mv kube-controller-manager.service /etc/systemd/system/
$ sudo systemctl daemon-reload
$ sudo systemctl enable kube-controller-manager
$ sudo systemctl start kube-controller-manager
创建 kube-scheduler 的 systemd unit 文件
& kube-scheduler.service
Description=Kubernetes Scheduler
Documentation=https:///GoogleCloudPlatform/kubernetes
ExecStart=/bin/kube-scheduler \\
--address=127.0.0.1 \\
--master=http://${MASTER_IP}:8080 \\
--leader-elect=true \\
Restart=on-failure
RestartSec=5
WantedBy=multi-user.target
启动kube-scheduler服务
$ sudo cp kube-scheduler.service /etc/systemd/system/
$ sudo systemctl daemon-reload
$ sudo systemctl enable kube-scheduler
$ sudo systemctl start kube-scheduler
验证master节点功能
$ kubectl get componentstatuses
controller-manager
{"health": "true"}
{"health": "true"}
部署node节点
kubernetes Node 节点包含如下组件：
kube-proxy
下载安装docker（建议不要使用ce版本）
$ wget https://get.docker.com/builds/Linux/x86_64/docker-1.13.1.tgz
$ tar -xvf docker-1.13.1.tgz
$ cp docker/docker* /bin
$ cp docker/completion/bash/docker /etc/bash_completion.d/
创建 docker 的 systemd unit 文件
& docker.service
Description=Docker Application Container Engine
Documentation=http://docs.docker.io
Environment="PATH=/bin:/sbin:/usr/bin:/usr/sbin"
EnvironmentFile=-/run/flannel/docker
ExecStart=/bin/dockerd --log-level=error $DOCKER_NETWORK_OPTIONS
ExecReload=/bin/kill -s HUP $MAINPID
Restart=on-failure
RestartSec=5
LimitNOFILE=infinity
LimitNPROC=infinity
LimitCORE=infinity
Delegate=yes
KillMode=process
WantedBy=multi-user.target
docker 从 1.13 版本开始，可能将 iptables FORWARD chain的默认策略设置为DROP，从而导致 ping 其它 Node 上的 Pod IP 失败，遇到这种情况时，需要手动设置策略为 ACCEPT
$ sudo iptables -P FORWARD ACCEPT
sleep 60 && /sbin/iptables -P FORWARD ACCEPT
为了加快 pull image 的速度，可以使用国内的仓库镜像服务器，同时增加下载的并发数。(如果 dockerd 已经运行，则需要重启 dockerd 生效。)
$ mkdir /etc/docker
$ cat & /etc/docker/daemon.json &&EOF
启动docker
$ sudo mv docker.service /etc/systemd/system/docker.service
$ sudo systemctl daemon-reload
$ sudo systemctl stop firewalld
$ sudo systemctl disable firewalld
$ sudo iptables -F && sudo iptables -X && sudo iptables -F -t nat && sudo iptables -X -t nat
$ sudo systemctl enable docker
$ sudo systemctl start docker
$ docker version
API version:
Go version:
Git commit:
8 08:47:51 2017
linux/amd64
API version:
1.26 (minimum version 1.12)
Go version:
Git commit:
8 08:47:51 2017
linux/amd64
Experimental: false
通过ifconfig查看网卡信息，保证docker0 与 flanneld网卡的在一个网段，如果不在一个网段集群服务是不正常的。导致这块原因有可能是粘贴上述docker.service信息时，ExecStart=/root/local/bin/dockerd --log-level=error $DOCKER_NETWORK_OPTIONS ExecReload=/bin/kill -s HUP $MAINPID被遗漏，所以需要手动加上，并删除docker0网卡重新加载启动。 虚拟网卡docker0其实是一个网桥，是启动Docker Daemon时创建的。传统的删除网卡方式不好用，下次daemon启动（假设没有指定-b参数）时，又会自动创建docker0网桥，可以按照如下步骤进行删除：
$ systemctl stop docker
$ vim /etc/systemd/system/docker.service
$ systemctl daemon-reload
$ yum install -y net-tools bridge-utils
$ ifconfig docker0 down
$ brctl delbr docker0
$ systemctl start docker
安装和配置 kubelet
以下操作只用在master上执行
kubelet 启动时向 kube-apiserver 发送 TLS bootstrapping 请求，需要先将 bootstrap token 文件中的 kubelet-bootstrap 用户赋予 system:node-bootstrapper 角色，然后 kubelet 才有权限创建认证请求(certificatesigningrequests)
$ kubectl create clusterrolebinding kubelet-bootstrap --clusterrole=system:node-bootstrapper --user=kubelet-bootstrap
--user=kubelet-bootstrap 是文件 /etc/kubernetes/token.csv 中指定的用户名，同时也写入了文件 /etc/kubernetes/bootstrap.kubeconfig；
以上操作只用在master上执行
下载最新的 kubelet 和 kube-proxy 二进制文件
$ wget https://dl.k8s.io/v1.6.2/kubernetes-server-linux-amd64.tar.gz
$ tar -xzvf kubernetes-server-linux-amd64.tar.gz
$ cd kubernetes
$ tar -xzvf
kubernetes-src.tar.gz
$ sudo cp -r ./server/bin/{kube-proxy,kubelet} /bin/
创建 kubelet bootstrapping kubeconfig 文件
$ **# 设置集群参数**
$ kubectl config set-cluster kubernetes \
--certificate-authority=/etc/kubernetes/ssl/ca.pem \
--embed-certs=true \
--server=${KUBE_APISERVER} \
--kubeconfig=bootstrap.kubeconfig
$ **# 设置客户端认证参数**
$ kubectl config set-credentials kubelet-bootstrap \
--token=${BOOTSTRAP_TOKEN} \
--kubeconfig=bootstrap.kubeconfig
$ **# 设置上下文参数**
$ kubectl config set-context default \
--cluster=kubernetes \
--user=kubelet-bootstrap \
--kubeconfig=bootstrap.kubeconfig
$ **# 设置默认上下文**
$ kubectl config use-context default --kubeconfig=bootstrap.kubeconfig
$ cp bootstrap.kubeconfig /etc/kubernetes/
创建 kubelet 的 systemd unit 文件
$ sudo mkdir /var/lib/kubelet **# 必须先创建工作目录**
$ cat & kubelet.service &&EOF
Description=Kubernetes Kubelet
Documentation=/GoogleCloudPlatform/kubernetes
After=docker.service
Requires=docker.service
WorkingDirectory=/var/lib/kubelet
ExecStart=/bin/kubelet \\
--address=${NODE_IP} \\
--hostname-override=${NODE_IP} \\
--pod-infra-container-image=registry./rhel7/pod-infrastructure:latest \\
--experimental-bootstrap-kubeconfig=/etc/kubernetes/bootstrap.kubeconfig \\
--kubeconfig=/etc/kubernetes/kubelet.kubeconfig \\
--require-kubeconfig \\
--cert-dir=/etc/kubernetes/ssl \\
--cluster-dns=${CLUSTER_DNS_SVC_IP} \\
--cluster-domain=${CLUSTER_DNS_DOMAIN} \\
--hairpin-mode promiscuous-bridge \\
--allow-privileged=true \\
--serialize-image-pulls=false \\
--logtostderr=true \\
ExecStartPost=/sbin/iptables -A INPUT -s 10.0.0.0/8 -p tcp --dport 4194 -j ACCEPT
ExecStartPost=/sbin/iptables -A INPUT -s 172.16.0.0/12 -p tcp --dport 4194 -j ACCEPT
ExecStartPost=/sbin/iptables -A INPUT -s 192.168.0.0/16 -p tcp --dport 4194 -j ACCEPT
ExecStartPost=/sbin/iptables -A INPUT -p tcp --dport 4194 -j DROP
Restart=on-failure
RestartSec=5
WantedBy=multi-user.target
启动kubelet服务
$ sudo mv kubelet.service /etc/systemd/system/kubelet.service
$ sudo systemctl daemon-reload
$ sudo systemctl enable kubelet
$ sudo systemctl start kubelet
$ systemctl status kubelet
通过 kubelet 的 TLS 证书请求
kubelet 首次启动时向 kube-apiserver 发送证书签名请求，必须通过后 kubernetes 系统才会将该 Node 加入到集群。
查看未授权的 CSR 请求
$ kubectl get csr
kubelet-bootstrap
$ kubectl get nodes
No resources found.
通过 CSR 请求
$ kubectl certificate approve csr-5g5t6
certificatesigningrequest "csr-5g5t6" approved
$ kubectl get nodes
#自动生成了 kubelet kubeconfig 文件和公私钥：
$ ls -l /etc/kubernetes/kubelet.kubeconfig
-rw-------. 1 root root 2276 Nov
8 11:49 /etc/kubernetes/kubelet.kubeconfig
$ ls -l /etc/kubernetes/ssl/kubelet*
-rw-r--r--. 1 root root 1042 Nov
8 11:49 /etc/kubernetes/ssl/kubelet-client.crt
-rw-------. 1 root root
8 11:46 /etc/kubernetes/ssl/kubelet-client.key
-rw-r--r--. 1 root root 1103 Nov
8 11:49 /etc/kubernetes/ssl/kubelet.crt
-rw-------. 1 root root 1679 Nov
8 11:49 /etc/kubernetes/ssl/kubelet.key
生成kube-proxy证书
$ cat & kube-proxy-csr.json &&EOF
"CN": "system:kube-proxy",
"hosts": [],
"algo": "rsa",
"size": 2048
"names": [
"C": "CN",
"ST": "BeiJing",
"L": "BeiJing",
"O": "k8s",
"OU": "System"
$ cfssl gencert -ca=./ca.pem -ca-key=./ca-key.pem -config=./ca-config.json -profile=kubernetes kube-proxy-csr.json | cfssljson -bare kube-proxy
$ ls kube-proxy*
kube-proxy.csr
kube-proxy-csr.json
kube-proxy-key.pem
kube-proxy.pem
将事先创建好的kubernetes-proxy*.pem拷贝到集群/etc/kubernetes/ssl下
$ sudo cp kube-proxy*.pem /etc/kubernetes/ssl/
创建 kube-proxy kubeconfig 文件
$ **# 设置集群参数**
$ kubectl config set-cluster kubernetes \
--certificate-authority=/etc/kubernetes/ssl/ca.pem \
--embed-certs=true \
--server=${KUBE_APISERVER} \
--kubeconfig=kube-proxy.kubeconfig
$ **# 设置客户端认证参数**
$ kubectl config set-credentials kube-proxy \
--client-certificate=/etc/kubernetes/ssl/kube-proxy.pem \
--client-key=/etc/kubernetes/ssl/kube-proxy-key.pem \
--embed-certs=true \
--kubeconfig=kube-proxy.kubeconfig
$ **# 设置上下文参数**
$ kubectl config set-context default \
--cluster=kubernetes \
--user=kube-proxy \
--kubeconfig=kube-proxy.kubeconfig
$ **# 设置默认上下文**
$ kubectl config use-context default --kubeconfig=kube-proxy.kubeconfig
$ cp kube-proxy.kubeconfig /etc/kubernetes/
创建 kube-proxy 的 systemd unit 文件
$ sudo mkdir -p /var/lib/kube-proxy # 必须先创建工作目录
$ cat & kube-proxy.service &&EOF
Description=Kubernetes Kube-Proxy Server
Documentation=/GoogleCloudPlatform/kubernetes
After=network.target
WorkingDirectory=/var/lib/kube-proxy
ExecStart=/bin/kube-proxy \\
--bind-address=${NODE_IP} \\
--hostname-override=${NODE_IP} \\
--cluster-cidr=${SERVICE_CIDR} \\
--kubeconfig=/etc/kubernetes/kube-proxy.kubeconfig \\
--logtostderr=true \\
Restart=on-failure
RestartSec=5
LimitNOFILE=65536
WantedBy=multi-user.target
启动kube-proxy服务
$ sudo mv kube-proxy.service /etc/systemd/system/
$ sudo systemctl daemon-reload
$ sudo systemctl enable kube-proxy
$ sudo systemctl start kube-proxy
$ systemctl status kube-proxy
全新node加入集群主要注意事项
export export NODE_IP=10.1.0.74
#环境变量需要修改当前节点ip
1.安装flanneld注意
确保/etc/flanneld/ssl下的证书与/etc/kubernetes/ssl/ca.pem
先安装docker并启动的话，可能docker0和flanneld不在一个网段，所以需要先启动flanneld
2.安装docker
如果存在服务起不来的现象，删除/var/lib/docker目录，再启动一次
3.一定确保/etc/flanneld/ssl下有其证书及密钥文件
执行/bin/etcdctl \
--endpoints=${ETCD_ENDPOINTS} \
--ca-file=/etc/kubernetes/ssl/ca.pem \
--cert-file=/etc/flanneld/ssl/flanneld.pem \
--key-file=/etc/flanneld/ssl/flanneld-key.pem \
set ${FLANNEL_ETCD_PREFIX}/config '{"Network":"'${CLUSTER_CIDR}'", "SubnetLen": 24, "Backend": {"Type": "vxlan"}}'
4.安装kubelet注意
切忌不能将其他/etc/kubernetes/ssl下的kubelet-client.crt和kubelet-client.key直接拷贝到新的node上(因为这两个及/etc/kubernetes/kubelet.kubeconfig是当master进行csr验证后自动生成的)
5.安装kube-proxy
dns插件部署
部署私有库
#安装docker(大于1.10.0版本)
yum -y install docker
#安装docker-compose(大于1.6版本)
curl -L https://github.com/docker/compose/releases/download/1.14.0/docker-compose-`uname -s`-`uname -m` & /usr/bin/docker-compose
chmod +x /usr/bin/docker-compose
#下载harbor安装，在有网络的情况下，下载online(小文件即可)
https://github.com/vmware/harbor/releases
#源码 git clone /vmware/harbor.git
tar zxvf harbor-online-installer-v1.1.2.tgz
#根据需求修改harbor.cfg 为方便下序安装，这里定义：
hostname = harbor.test.com
#执行安装脚本
./install.sh
#安装完毕后即可通过登录(端口可以通过docker-compose.yml进行修改)
#由于采用了默认的 http 方式连接，而 Docker 认为这是不安全的，所以在 push 之前需要调整一下 docker 配置
vim /etc/sysconfig/docker
#增加DOCKER_OPTS=--insecure-registry
确保有/etc/docker/certs.d/10.1.0.78/ca.crt文件
即可通过docker login harbor.test.com进行登录，随后push
push的原则是docker push harbor.test.com/项目名称/镜像名称:版本号。
至此，harbor私有库搭建完毕。
参考https://github.com/vmware/harbor/blob/master/docs/installation_guide.md
问题&&答案
1.node超过指定时间未上报自己状态时。master会判定其为“失联”，从而标记成notready,并且开始转移负载（既失联node上的实例转移到ready的node上）
2.为什么镜像用docker run启动时没问题，而用k8s的rc\deployment启动时会一直处于死循环。
因为k8s对于长期运行的容器要求是：其程序要一直在前台运行，如果镜像的启动命令为后台执行，那么在Pod建立的第一时间，k8s认为pod执行结束。将立即销毁pod。所以对于无法改造成前台运行的应用。应该借助Supervisor辅助进行前台运行
3.dns服务，进入容器后无法ping通非默认systemspaces的service服务地址。比如在kube-system组里的服务，ping的时候需要是 ping kube-dns**.kube-system.svc.cluster.local** ,若要直接ping kube-dns实现。则在kubernetes-csr.json中需要提前定义。"kubernetes.**kube-system**.svc.cluster.local"
k8s访问集群外独立的服务最好的方式是采用Endpoint方式(可以看作是将k8s集群之外的服务抽象为内部服务)，以mysql服务为例：
创建mysql-endpoints.yaml
apiVersion: v1
kind: Endpoints
name: mysql-test
namespace: default
- addresses:
- ip: 10.1.0.32
- port: 3306
多个端口的话可以在此处列出
创建mysql-service.yaml
apiVersion: v1
kind: Service
name: mysql-test
- port: 3306
同样多端口需要列出
测试连接数据库：
[root@LOC-XAN-PRO-032 run]
PING mysql-test (10.254.121.162): 56 data bytes
11 packets transmitted, 0 packets received, 100% packet loss
ERROR 1045 (28000): Access denied for user 'bill'@'172.30.95.10' (using password: YES)
Welcome to the MariaDB monitor.
Commands end with ; or \g.
Your MariaDB connection id is 3
Server version: 5.5.52-MariaDB MariaDB Server
Copyright (c) 2000, 2016, Oracle, MariaDB Corporation Ab and others.
Type '' or '\h' for help. Type '\c' to clear the current input statement.
MariaDB [(none)]&
| Database
| information_schema |
3 rows in set (0.00 sec)
MariaDB [(none)]&
查看这个service
[root@LOC-XAN-PRO-032 mysql]
mysql-test
Namespace:
Annotations:
10.254.121.162
&unset& 3306/TCP
Endpoints:
10.1.0.32:3306
Session Affinity:
参考连接：
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：4145次
排名：千里之外
原创：10篇
(1)(1)(1)(2)(6)
(window.slotbydup = window.slotbydup || []).push({
id: '4740887',
container: s,
size: '250,250',
display: 'inlay-fix'