如何在CentOS上创建Kubernetes集群?

  • 回答 (9)
  • 关注 (2)
  • 查看 (560)

Kubernetes(常简称为K8s)是用于自动部署、扩展和管理容器化(containerized)应用程序的开源系统。Google设计并捐赠给Linux基金会来使用的。它旨在提供“跨主机集群的自动部署、扩展以及运行应用程序容器的平台”。它支持一系列容器工具, 包括Docker等。

独善其身独善其身提问于
土子美互联网从业者回答于

系统环境

kubeadm支持多种系统,这里简单介绍一下需要的系统要求:

  1. Ubuntu16.04+ / Debian 9 / CentOS 7 / RHEL 7 / Fedora 25/26(best-effort) / HypriotOS v1.0.1+ / Other
  2. 2GB或者以上的RAM(否则将没有足够空间留给app)
  3. 2核以上CPU
  4. 集群的机器之间必须能通过网络互相通信
  5. SWAP必须被关闭,否则kubelet会出错!

具体的详细信息可以在官方网站上看到。

本篇内容基于aws的ap-northeast-1的ec2, CentOS7的操作系统(ami-4dd5522b),实例类型t2.medium 2核4GB,3台机器,1 master,2 nodes,kubernetes 1.9 版本。为了方便起见,在安全组里面打开了所有的端口和IP访问。

机器配置:

[centos@ip-172-31-24-49 ~]$ uname -a
Linux ip-172-31-24-49.ap-northeast-1.compute.internal 3.10.0-693.5.2.el7.x86_64 #1 SMP Fri Oct 20 20:32:50 UTC 2017 x86_64 x86_64 x86_64 GNU/Linux

首先 ,我们关闭selinux:

$ sudo vim /etc/sysconfig/selinux

把SELINUX改成disabled,然后保存退出。

在我用的ami中,swap是默认关闭的,所以不需要我手动关闭,大家需要确认 自己的环境中swap是否有关闭掉,否则会在之后的环节中出问题。

为了方便我们安装,我们将sshd设置为keepalive:

$ sudo -i
$ echo "ClientAliveInterval 10" >> /etc/ssh/sshd_config
$ echo "TCPKeepAlive yes" >> /etc/ssh/sshd_config
$ systemctl restart sshd.service

接下来我们重启一下机器:

$ sudo sync
$ sudo reboot

至此,准备阶段结束。

安装kubeadm

首先,我们需要在所有机器上都安装 docker, kubeadm, kubeletkubectl

切记:kubeadm不会自动去安装和管理 kubelet和kubectl,所以需要自己去确保安装的版本和你想要安装的kubernetes版本相同。

安装 docker

$ sudo yum install -y docker
$ sudo systemctl enable docker && sudo systemctl start docker

在RHEL/CentOS 7 系统上可能会路由失败,我们需要设置一下:

$ sudo -i
$ cat <<EOF >  /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF
$ sudo sysctl --system

接下来我们需要安装 kubeadm, kubeletkubectl了,我们需要先加一个repo:

$ cat <<EOF > /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg
EOF

然后安装:

$ sudo yum install -y kubelet kubeadm kubectl
$ sudo systemctl enable kubelet && sudo systemctl start kubelet

至此,在所有机器上安装所需的软件已经结束。

使用kubeadm初始化master

安装完所有的依赖之后,我们就可以用 kubeadm初始化master了。

最简单的初始化方法是:

$ kubeadm init

除此之外, kubeadm还支持多种方法来配置,具体可以查看一下官方文档。

我们在初始化的时候指定一下kubernetes版本,并设置一下pod-network-cidr(后面的flannel会用到):

$ sudo -i
$ kubeadm init --kubernetes-version=v1.9.0 --pod-network-cidr=10.244.0.0/16

在这个过程中 kubeadm执行了一系列的操作,包括一些pre-check,生成ca证书,安装etcd和其它控制组件等。

界面差不多如下:

最下面的这行 kubeadm join什么的,就是用来让别的node加入集群的,可以看出非常方便。我们要保存好这一行东西,这是我们之后让node加入集群的凭据,一会儿会用到。

这个时候,我们还不能通过 kubectl来控制集群,要让 kubectl可用,我们需要做:

# 对于非root用户
$ mkdir -p $HOME/.kube
$ sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
$ sudo chown $(id -u):$(id -g) $HOME/.kube/config

# 对于root用户
$ export KUBECONFIG=/etc/kubernetes/admin.conf
# 也可以直接放到~/.bash_profile
$ echo "export KUBECONFIG=/etc/kubernetes/admin.conf" >> ~/.bash_profile

接下来要注意,我们必须自己来安装一个network addon。

network addon必须在任何app部署之前安装好。同样的,kube-dns也会在network addon安装好之后才启动。kubeadm只支持CNI-based networks(不支持kubenet)。

比较常见的network addon有: Calico, Canal, Flannel, Kube-router, Romana, WeaveNet等。这里我们使用 Flannel

$ kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/v0.9.1/Documentation/kube-flannel.yml

安装完network之后,你可以通过 kubectlgetpods--all-namespaces来查看 kube-dns是否在running来判断network是否安装成功。

默认情况下,为了保证master的安全,master是不会被调度到app的。你可以取消这个限制通过输入:

$ kubectl taint nodes --all node-role.kubernetes.io/master-

加入nodes

终于部署完了我们的master!

现在我们开始加入一些node到我们的集群里面吧!

ssh到我们的node节点上,执行刚才下面给出的那个 kubeadm join的命令(每个人不同):

$ sudo -i
$ kubeadm join --token 72a8a4.2ed9076cd668b8b7 172.31.31.60:6443 --discovery-token-ca-cert-hash sha256:f0894e55d475f882dd40d52c6d01f758017ec5729be632294049f687330f60d2

输出差不多如下图:

这时候,我们去master上输入 kubectlgetnodes查看一下:

[root@i-071abd86ed304dc84 ~]# kubectl get nodes
NAME                  STATUS    ROLES     AGE       VERSION
i-071abd86ed304dc84   Ready     master    12m       v1.9.0
i-0c559ad3c0b16fd36   Ready     <none>    1m        v1.9.0
i-0f3f7462b0a004b5e   Ready     <none>    47s       v1.9.0
小楼CF龙行九天,沐风化雨!You are the one!回答于

群集将包含以下物理资源:

  • 一个主节点

主节点(Kubernetes中的节点指的是服务器)负责管理集群的状态。我们将用它运行Etcd,该服务器目的是将工作负载调度到工作节点的组件之间存储集群数据。

  • 两个工作节点

工作节点是运行工作负载(即容器化应用程序和服务)的服务器。一旦工作节点分配了工作负载,工作节点将继续运行您的工作负载,即使计划在调度完成后停止工作也是如此。通过添加工作节点可以增加群集的容量。

完成本教程后,您将拥有一个可以运行容器化应用程序的集群,前提是集群中的服务器具有足够的CPU和RAM资源供应用程序使用。几乎任何传统的Unix应用程序(包括Web应用程序,数据库,守护程序和命令行工具)都可以进行容器化,并在集群上运行。群集本身将在每个节点上消耗大约300-500MB的内存和10%的CPU。

设置群集后,您将部署Web服务器Nginx以确保它正确运行。

准备

  • 本地Linux / macOS /BSD计算机上的SSH密钥对。如果您之前没有使用过SSH密钥,同时使用的是腾讯云的服务器的话,请参考创建 SSH 密钥文档。如果您使用的不是腾讯云的服务器,请自行搜索,本文暂不涉及。本教程的本地计算机是Linux操作系统,请勿使用Windows进行试验。
  • 运行CentOS 7的三台服务器,内存至少为1GB。没有服务器的同学可以在这里购买,不过我个人更推荐您使用免费的腾讯云开发者实验室进行试验,学会安装后在购买服务器。您应该能够以SSH密钥对的root用户身份SSH到每个服务器。请务必将您的公钥添加到主节点上的centos用户帐户。如果您需要有关向特定用户帐户添加SSH密钥的指导,请参阅密钥绑定/解绑服务器文档。
  • Ansible需要安装在您的本地计算机上。有关安装说明,请按照Ansible官方安装文档
  • 了解如何从Docker镜像启动容器。如果需要复习,请参阅如何安装使用Docker的“第5步 - 运行Docker容器” 。

第1步 - 设置工作区目录和Ansible配置

在本节中,您将在本地计算机上创建一个用作工作区的目录。您还将在本地配置Ansible,以便它可以与远程服务器上的命令进行通信。为此,您将创建一个hosts文件包,其包含例如服务器的IP地址和每个服务器所属的组等信息。

在三台服务器中,一台服务器将作为主服务器master_ip。另外两台服务器则是是工作节点,并拥有IPworker_1_ipworker_2_ip

在本地计算机的主目录中创建一个名为~/kube-cluster/hosts的目录并进入其中:

mkdir ~/kube-cluster
cd ~/kube-cluster

该目录将是本教程的工作区,包含所有Ansible设置。它也将是您运行所有本地命令的目录。

使用vi命令创建一个名为~/kube-cluster/hosts的文件或用您最喜欢的文本编辑器:

vi ~/kube-cluster/hosts

i将以下文本插入到文件中,该文件将指定有关群集逻辑结构的信息:

[masters]
master ansible_host=master_ip ansible_user=root
​
[workers]
worker1 ansible_host=worker_1_ip ansible_user=root
worker2 ansible_host=worker_2_ip ansible_user=root

完成后,按,ESC然后输入:wq将更改写入文件并退出。

您可能还记得在Ansible中用于指定服务器信息的库存文件,例如IP地址,远程用户和服务器分组,以作为执行命令的单个单元进行目标。~/kube-cluster/hosts将是您的库存文件,并且您已向其添加了两个Ansible组(主服务器工作服务器),用于指定集群的逻辑结构。

服务器组中,有一个名为“master”的服务器,其中列出了主节点的IP(master_ip),并指定Ansible应以根用户身份运行远程命令。

同样,在workers组中,有两个工作服务器(worker_1_ipworker_2_ip),它们也需要指定ansible_user为root用户。

在设置服务器清单之后,让我们继续安装操作系统级依赖关系并创建配置设置。

第2步 - 安装Kubernetes的依赖项

在本节中,您将使用CentOS的yum软件包管理器安装Kubernetes所需的软件包。这些包是:

  • Docker - 容器运行时。这是运行容器的组件。Kubernetes正在积极开发对rkt等其他运行容器服务的支持。
  • kubeadm - CLI工具,以标准方式安装和配置群集的各个组件。
  • kubelet - 在所有节点上运行并处理节点级操作的系统服务/程序。
  • kubectl- 通过其API服务器向集群发出命令的CLI工具。

创建工作空间中指定的文件vi ~/kube-cluster/kube-dependencies.yml

vi ~/kube-cluster/kube-dependencies.yml

将下面的内容插到文件内:

- hosts: all
  become: yes
  tasks:
   - name: install Docker
     yum:
       name: docker
       state: present
       update_cache: true
​
   - name: start Docker
     service:
       name: docker
       state: started
​
   - name: disable SELinux
     command: setenforce 0
​
   - name: disable SELinux on reboot
     selinux:
       state: disabled
​
   - name: ensure net.bridge.bridge-nf-call-ip6tables is set to 1
     sysctl:
      name: net.bridge.bridge-nf-call-ip6tables
      value: 1
      state: present
​
   - name: ensure net.bridge.bridge-nf-call-iptables is set to 1
     sysctl:
      name: net.bridge.bridge-nf-call-iptables
      value: 1
      state: present
​
   - name: add Kubernetes' YUM repository
     yum_repository:
      name: Kubernetes
      description: Kubernetes YUM repository
      baseurl: https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64
      gpgkey: https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg
      gpgcheck: yes
​
   - name: install kubelet
     yum:
        name: kubelet
        state: present
        update_cache: true
​
   - name: install kubeadm
     yum:
        name: kubeadm
        state: present
​
   - name: start kubelet
     service:
       name: kubelet
       enabled: yes
       state: started
​
- hosts: master
  become: yes
  tasks:
   - name: install kubectl
     yum:
        name: kubectl
        state: present

文件中的的第一部分内容如下:

  • 容器运行时,安装Docker。
  • 启动Docker服务。
  • 请禁用SELinux,因为Kubernetes尚未完全支持它。
  • 设置网络所需的一些与netfilter相关的sysctl值。这将允许Kubernetes设置iptables规则,以便在节点上接收桥接的IPv4和IPv6网络流量。
  • 将Kubernetes YUM存储库添加到远程服务器的存储库列表中。
  • 安装kubeletkubeadm

第二部分意思是在主节点上设置一下kubectl的任务。

完成后保存并关闭文件。

接下来,执行playbook

ansible-playbook -i hosts ~/kube-cluster/kube-dependencies.yml

完成后,您将看到类似于以下内容的输出:

PLAY [all] ****
​
TASK [Gathering Facts] ****
ok: [worker1]
ok: [worker2]
ok: [master]
​
TASK [install Docker] ****
changed: [master]
changed: [worker1]
changed: [worker2]
​
TASK [disable SELinux] ****
changed: [master]
changed: [worker1]
changed: [worker2]
​
TASK [disable SELinux on reboot] ****
changed: [master]
changed: [worker1]
changed: [worker2]
​
TASK [ensure net.bridge.bridge-nf-call-ip6tables is set to 1] ****
changed: [master]
changed: [worker1]
changed: [worker2]
​
TASK [ensure net.bridge.bridge-nf-call-iptables is set to 1] ****
changed: [master]
changed: [worker1]
changed: [worker2]
​
TASK [start Docker] ****
changed: [master]
changed: [worker1]
changed: [worker2]
​
TASK [add Kubernetes' YUM repository] *****
changed: [master]
changed: [worker1]
changed: [worker2]
​
TASK [install kubelet] *****
changed: [master]
changed: [worker1]
changed: [worker2]
​
TASK [install kubeadm] *****
changed: [master]
changed: [worker1]
changed: [worker2]
​
TASK [start kubelet] ****
changed: [master]
changed: [worker1]
changed: [worker2]
​
PLAY [master] *****
​
TASK [Gathering Facts] *****
ok: [master]
​
TASK [install kubectl] ******
ok: [master]
​
PLAY RECAP ****
master                     : ok=9    changed=5    unreachable=0    failed=0   
worker1                    : ok=7    changed=5    unreachable=0    failed=0  
worker2                    : ok=7    changed=5    unreachable=0    failed=0  

执行后,Docker,kubeadmkubelet将安装在所有远程服务。kubectl不是必需组件,仅用于执行集群命令。但是我们建议您还是安装它,因为您将仅从主节点运行kubectl命令。

现在安装了所有系统依赖项。让我们设置主节点并初始化集群。

第3步 - 设置主节点

在本节中,您将设置主节点。然而在创建配置之前,我们需要熟悉几个概念,如PodsPod 网络插件

Kubernetes的基本调度单元称为“pods”。它可以把更高级别的抽象内容增加到容器化组件。一个pod一般包含一个或多个容器,这样可以保证它们一直位于主机上,并且可以共享资源。Kubernetes中的每个pod都被分配一个唯一的(在集群内的)IP地址这样就可以允许应用程序使用端口,而不会有冲突的风险。Pod可以定义一个卷,例如本地磁盘目录或网络磁盘,并将其暴露在pod中的一个容器之中。pod可以通过Kubernetes API手动管理,也可以委托给控制器来管理。

每个pod都有自己的IP地址,一个节点上的pod应该能够使用pod的IP访问另一个节点上的pod。单个节点上的容器可以通过本地接口轻松进行通信。然而,pod之间的通信更复杂,并且需要单独的网络组件,该组件可以透明地将流量从一个节点上的pod传送到另一个节点上的pod。此功能由pod网络插件提供。对于这个群集,建议您将使用Flannel选项

在本地计算机上创建一个命名为master.yml的Ansible playbook :

vi ~/kube-cluster/master.yml

将以下内容添加到文件中以初始化集群并安装Flannel:

- hosts: master
  become: yes
  tasks:
    - name: initialize the cluster
      shell: kubeadm init --pod-network-cidr=10.244.0.0/16 >> cluster_initialized.txt
      args:
        chdir: $HOME
        creates: cluster_initialized.txt
​
    - name: create .kube directory
      become: yes
      become_user: centos
      file:
        path: $HOME/.kube
        state: directory
        mode: 0755
​
    - name: copy admin.conf to user's kube config
      copy:
        src: /etc/kubernetes/admin.conf
        dest: /home/centos/.kube/config
        remote_src: yes
        owner: centos
​
    - name: install Pod network
      become: yes
      become_user: centos
      shell: kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/v0.9.1/Documentation/kube-flannel.yml >> pod_network_setup.txt
      args:
        chdir: $HOME
        creates: pod_network_setup.txt

这是上面内容的详解:

  • 第一个任务通过运行kubeadm init初始化集群。传递--pod-network-cidr=10.244.0.0/16参数指定将从中分配pod IP的私有子网。Flannel默认使用上述子网,我们告诉kubeadm使用相同的子网。
  • 第二个任务创建一个.kube目录在/home/centos。此目录将保存配置信息,例如连接到群集所需的管理密钥文件以及群集的API地址。
  • 第三个任务将/etc/kubernetes/admin.conf生成的文件复制kubeadm initcentos用户的主目录。这将允许您用kubectl访问新创建的群集。
  • 最后一个任务运行kubectl apply安装Flannelkubectl apply -f descriptor.[yml|json]是告诉kubectl创建descriptor.[yml|json]文件中描述的对象的语法。kube-flannel.yml文件包含Flannel在群集中设置所需的对象的说明。

完成后保存并关闭文件。执行配置:

ansible-playbook -i hosts ~/kube-cluster/master.yml

完成后,您将看到类似于以下内容的输出:

​
PLAY [master] ****
​
TASK [Gathering Facts] ****
ok: [master]
​
TASK [initialize the cluster] ****
changed: [master]
​
TASK [create .kube directory] ****
changed: [master]
​
TASK [copy admin.conf to user's kube config] *****
changed: [master]
​
TASK [install Pod network] *****
changed: [master]
​
PLAY RECAP ****
master                     : ok=5    changed=4    unreachable=0    failed=0  

要检查主节点的状态,请使用以下命令通过SSH连接到该节点:

ssh centos@master_ip

进入主节点后,执行:

kubectl get nodes

您现在将看到以下输出:

NAME      STATUS    ROLES     AGE       VERSION
master    Ready     master    1d        v1.10.1

输出表明master节点已完成所有初始化任务,并且处于Ready可以开始接受工作节点并执行发送到API服务器的任务的状态。您现在可以从本地计算机添加工作程序。

第4步 - 设置工作节点

将工作程序添加到集群涉及在每个集群上执行单个命令。此命令包括必要的群集信息,例如主服务器API服务器的IP地址和端口以及安全令牌。只有传入安全令牌的节点才能加入群集。

f反回您的工作区并创建一个名为workers.yml的配置:

vi ~/kube-cluster/workers.yml

将以下文本添加到文件中:

- hosts: master
  become: yes
  gather_facts: false
  tasks:
    - name: get join command
      shell: kubeadm token create --print-join-command
      register: join_command_raw
​
    - name: set join command
      set_fact:
        join_command: "{{ join_command_raw.stdout_lines[0] }}"
​
​
- hosts: workers
  become: yes
  tasks:
    - name: join cluster
      shell: "{{ hostvars['master'].join_command }} >> node_joined.txt"
      args:
        chdir: $HOME
        creates: node_joined.txt

以下是配置的作用:

  • 第一个配置获取join命令,以便在worker节点上运行。该命令将采用以下格式:kubeadm join --token <token> <master-ip>:<master-port> --discovery-token-ca-cert-hash sha256:<hash>一旦它获得具有的令牌哈希值的命令,该任务就将其设置为可用,以便下一个配置能够访问该信息。
  • 第二个配置有一个任务,它在所有工作节点上运行join命令。完成此任务后,两个工作节点将成为群集的一部分。

完成后保存并关闭文件。执行配置:

ansible-playbook -i hosts ~/kube-cluster/workers.yml

完成后,您将看到类似于以下内容的输出:

PLAY [master] ****
​
TASK [get join command] ****
changed: [master]
​
TASK [set join command] *****
ok: [master]
​
PLAY [workers] *****
​
TASK [Gathering Facts] *****
ok: [worker1]
ok: [worker2]
​
TASK [join cluster] *****
changed: [worker1]
changed: [worker2]
​
PLAY RECAP *****
master                     : ok=2    changed=1    unreachable=0    failed=0   
worker1                    : ok=2    changed=1    unreachable=0    failed=0  
worker2                    : ok=2    changed=1    unreachable=0    failed=0  

通过添加工作节点,您的群集现在已完全设置并正常运行,工作节点可以随时运行工作负载。让我们验证群集是否按预期工作。

第5步 - 验证群集

集群有时可能在安装过​​程中失败,因为节点已关闭或主服务器与工作服务器之间的网络连接无法正常工作。让我们验证集群并确保节点正常运行。

您需要从主节点检查群集的当前状态,以确保节点已准备就绪。如果从主节点断开连接,则可以使用以下命令通过SSH将其重新连接到主节点:

ssh centos@master_ip

然后执行以下命令以获取集群的状态:

kubectl get nodes

您将看到类似于以下内容的输出:

NAME      STATUS    ROLES     AGE       VERSION
master    Ready     master    1d        v1.10.1
worker1   Ready     <none>    1d        v1.10.1 
worker2   Ready     <none>    1d        v1.10.1

如果所有的节点都具有ReadySTATUS(状态),这意味着它们是集群的一部分,并准备运行工作负载。

但是,如果几个节点拥有NotReadySTATUS(状态),它可能意味着工作节点还没有完成自己的设置。等待大约五到十分钟再重新运行kubectl get node并检查新输出。如果一些节点仍具有NotReady状态,则需要验证并重新运行前面步骤中的命令。

现在您的集群已成功验证,让我们在集群上部署一个示例Nginx应用程序。

第6步 - 在群集上运行应用程序

您现在可以将任何容器化应用程序部署到您的群集。让我们使用部署和服务部署Nginx,以了解如何将此应用程序部署到集群。如果更改Docker镜像名称和任何相关标志(例如portsvolumes),您也可以使用以下命令用于其他容器化应用程序。

在主节点内,执行以下命令以创建名为nginx的部署:

kubectl run nginx --image=nginx --port 80

部署是一种Kubernetes对象,可确保始终根据已定义的模板运行指定数量的pod,即使pod在群集生命周期内崩溃也是如此。上面的部署将使用Docker镜像库的Nginx Docker Image创建一个包含一个容器的pod 。

接下来,运行以下命令以创建名为nginx将公开公共应用程序的服务。它将通过NodePort实现,该方案将通过在群集的每个节点上打开的任意端口访问pod:

kubectl expose deploy nginx --port 80 --target-port 80 --type NodePort

服务是另一种类型的Kubernetes对象,它向内部和外部客户端公开集群内部服务。它们还能够对多个pod进行负载均衡请求,并且是Kubernetes中不可或缺的组件,经常与其他组件交互。

运行以下命令:

kubectl get services

这将输出类似于以下内容的文本:

NAME         TYPE        CLUSTER-IP       EXTERNAL-IP           PORT(S)        AGE
kubernetes   ClusterIP   10.96.0.1        <none>                443/TCP        1d
nginx        NodePort    10.109.228.209   <none>                80:nginx_port/TCP   40m

从上面输出的第三行,您可以检索运行Nginx的端口。Kubernetes将分配一个大于30000自动的随机端口,同时确保该端口尚未受到其他服务的约束。

要测试一切正常,请访问或通过本地计算机上的浏览器。您将看到Nginx熟悉的欢迎页面。http://worker_1_ip:nginx_port或者http://worker_2_ip:nginx_port

如果要删除Nginx应用程序,请先nginx从主节点删除该服务:

kubectl delete service nginx

运行以下命令以确保已删除该服务:

kubectl get services

您将看到以下输出:

NAME         TYPE        CLUSTER-IP       EXTERNAL-IP           PORT(S)        AGE
kubernetes   ClusterIP   10.96.0.1        <none>                443/TCP        1d

然后删除部署:

kubectl delete deployment nginx

运行以下命令以确认这是否有效:

kubectl get deployments
No resources found.
弯起嘴角笑在路上回答于

前提条件

由于要用到谷歌的服务,所以要求您的网络环境可以科学上网,具体的方案就不在这里说了;

复制文件

如下图所示,cent7是我们上一章操作完成后对应的CentOS7的VMware文件夹,现在把这个文件夹复制三份一模一样的,再分别重命名为maste、node1、node2:

启动master

打开VMware软件,选中上面我们复制的master文件夹,选中里面的文件然后点击“打开”按钮,如下图:

如下图,点击红框中的“编辑虚拟机设置”按钮

如下图,在设置页面中将虚拟机名字改成”master”:

如下图,点击红框中的按钮启动master:

如下图,在弹出的窗口中选择“我已复制该虚拟机”:

修改hostname再重启master

等master启动完毕,进入系统,修改/etc/hostname文件,这里面只有一行内容“localhost.localdomain”,改成”master”;

修改完hostname文件后,重启master;

启动kubelet服务

执行以下命令设置kubelet自启动,然后再启动kubelet服务:

systemctl enable kubelet;systemctl start kubelet

初始化kubernetes的master服务

执行以下命令,初始化kubernetes的master服务,此时由于要去下载谷歌服务的镜像文件,所以请保证当前网络可以科学上网:

kubeadm init --pod-network-cidr=192.168.0.0/16 --apiserver-advertise-address=0.0.0.0

如果网络没有问题,就请耐心等待吧,大约二十分钟就会完成init过程,如下图:

注意上图中的最后一句kubeadm join –token 4fccd2.b0e0f8918bd95d3e 192.168.119.132:6443,在node加入的时候我们就是用这一句来将node加入到集群的;

为什么init操作要用这么长时间呢?执行docker images命令可以看到下载多了很多镜像,如下图:

新增了6个镜像;

创建kube目录,添加kubectl配置

执行以下命令,把配置信息复制到执行目录中:

mkdir -p $HOME/.kube;cp -i /etc/kubernetes/admin.conf $HOME/.kube/config;chown $(id -u):$(id -g) $HOME/.kube/config

添加Calico(网络组件)

执行以下命令,安装Calico

kubectl apply -f http://docs.projectcalico.org/v2.4/getting-started/kubernetes/installation/hosted/kubeadm/1.6/calico.yaml

检查是否启动成功

执行以下命令,看基础服务的pod都起来了没有:

kubectl get pods --all-namespaces

看到的pod信息如下图所示,红框中有一个pod并不是Running状态,而是ContainerCreating:

这时候请耐心等待几分钟,再看就会变成下面的状态:

用docker images命令看一下,发现多了几个镜像,如下图:

用kubectl get node命令查看当前的节点信息,能看见只有一个master节点,如下图:

至此,kubernetes集群的master节点就安装完成了

未觉累不许说我笑点低!回答于

环境规划

角色

IP

主机名

组件

Master1

192.168.161.161

master1

etcd1,master1

master2

192.168.161.162

master2

etcd2,master2

node1

192.168.161.163

node1

kubelet,kube-proxy,docker,flannel

node2

192.168.161.164

node2

kubelet,kube-proxy,docker,flannel

  1. kube-apiserver:位于master节点,接受用户请求。
  2. kube-scheduler:位于master节点,负责资源调度,即pod建在哪个node节点。
  3. kube-controller-manager:位于master节点,包含ReplicationManager,Endpointscontroller,Namespacecontroller,Nodecontroller等。
  4. etcd:分布式键值存储系统,共享整个集群的资源对象信息。
  5. kubelet:位于node节点,负责维护在特定主机上运行的pod。
  6. kube-proxy:位于node节点,它起的作用是一个服务代理的角色。

再来普及一下:

① kubectl 发送部署请求到 API Server。

② API Server 通知 Controller Manager 创建一个 deployment 资源。

③ Scheduler 执行调度任务,将两个副本 Pod 分发到 k8s-node1 和 k8s-node2。

④ k8s-node1 和 k8s-node2 上的 kubectl 在各自的节点上创建并运行 Pod。

集群部署

  • 系统采用 Centos 7.3
  • 关闭防火墙
systemctl disable firewalld  
systemctl stop firewalld 
  • 关闭 selinux
  • 安装NTP并启动
# yum -y install ntp  
# systemctl start ntpd  
# systemctl enable ntpd

4台机器均设置好 hosts

vim /etc/hosts

192.168.161.161 master1
192.168.161.162 master2
192.168.161.163 node1
192.168.161.164 node2

192.168.161.161 etcd
192.168.161.162 etcd
3.1 部署master
安装etcd
[root@master1 ~]# yum -y install etcd
配置etcd

yum安装的etcd默认配置文件在/etc/etcd/etcd.conf,以下将2个节点上的配置贴出来,请注意不同点。

2379是默认的使用端口,为了防止端口占用问题的出现,增加4001端口备用。

master1:

[[email protected] ~]# vim /etc/etcd/etcd.conf 

# [member]  
ETCD_NAME=etcd1  
ETCD_DATA_DIR="/var/lib/etcd/test.etcd"  
#ETCD_WAL_DIR=""  
#ETCD_SNAPSHOT_COUNT="10000"  
#ETCD_HEARTBEAT_INTERVAL="100"  
#ETCD_ELECTION_TIMEOUT="1000"  
ETCD_LISTEN_PEER_URLS="http://0.0.0.0:2380"  
ETCD_LISTEN_CLIENT_URLS="http://0.0.0.0:2379,http://0.0.0.0:4001"  
#ETCD_MAX_SNAPSHOTS="5"  
#ETCD_MAX_WALS="5"  
#ETCD_CORS=""  
#  
#[cluster]  
ETCD_INITIAL_ADVERTISE_PEER_URLS="http://master1:2380"  
# if you use different ETCD_NAME (e.g. test), set ETCD_INITIAL_CLUSTER value for this name, i.e. "test=http://..."  
ETCD_INITIAL_CLUSTER="etcd1=http://master1:2380,etcd2=http://master2:2380"  
ETCD_INITIAL_CLUSTER_STATE="new"  
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster-baby"  
ETCD_ADVERTISE_CLIENT_URLS="http://master1:2379,http://master1:4001"

master2:

[[email protected] ~]# vim /etc/etcd/etcd.conf

# [member]  
ETCD_NAME=etcd2  
ETCD_DATA_DIR="/var/lib/etcd/test.etcd"  
#ETCD_WAL_DIR=""  
#ETCD_SNAPSHOT_COUNT="10000"  
#ETCD_HEARTBEAT_INTERVAL="100"  
#ETCD_ELECTION_TIMEOUT="1000"  
ETCD_LISTEN_PEER_URLS="http://0.0.0.0:2380"  
ETCD_LISTEN_CLIENT_URLS="http://0.0.0.0:2379,http://0.0.0.0:4001"  
#ETCD_MAX_SNAPSHOTS="5"  
#ETCD_MAX_WALS="5"  
#ETCD_CORS=""  
#  
#[cluster]  
ETCD_INITIAL_ADVERTISE_PEER_URLS="http://master2:2380"  
# if you use different ETCD_NAME (e.g. test), set ETCD_INITIAL_CLUSTER value for this name, i.e. "test=http://..."  
ETCD_INITIAL_CLUSTER="etcd1=http://master1:2380,etcd2=http://master2:2380"  
ETCD_INITIAL_CLUSTER_STATE="new"  
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster-baby"  
ETCD_ADVERTISE_CLIENT_URLS="http://master2:2379,http://master2:4001"
参数说明:
name      节点名称
data-dir      指定节点的数据存储目录
listen-peer-urls      监听URL,用于与其他节点通讯
listen-client-urls    对外提供服务的地址:比如 http://ip:2379,http://127.0.0.1:2379 ,客户端会连接到这里和 etcd 交互
initial-advertise-peer-urls   该节点同伴监听地址,这个值会告诉集群中其他节点
initial-cluster   集群中所有节点的信息,格式为 node1=http://ip1:2380,node2=http://ip2:2380,… 。注意:这里的 node1 是节点的 --name 指定的名字;后面的 ip1:2380 是 --initial-advertise-peer-urls 指定的值
initial-cluster-state     新建集群的时候,这个值为 new ;假如已经存在的集群,这个值为 existing
initial-cluster-token     创建集群的 token,这个值每个集群保持唯一。这样的话,如果你要重新创建集群,即使配置和之前一样,也会再次生成新的集群和节点 uuid;否则会导致多个集群之间的冲突,造成未知的错误
advertise-client-urls     对外公告的该节点客户端监听地址,这个值会告诉集群中其他节点

修改好以上配置后,在各个节点上启动etcd服务,并验证集群状态:

Master1

[[email protected] etcd]# systemctl start etcd

[[email protected] etcd]# etcdctl -C http://etcd:2379 cluster-health 
member 22a9f7f65563bff5 is healthy: got healthy result from http://master2:2379
member d03b92adc5af7320 is healthy: got healthy result from http://master1:2379
cluster is healthy

[[email protected] etcd]# etcdctl -C http://etcd:4001 cluster-health 
member 22a9f7f65563bff5 is healthy: got healthy result from http://master2:2379
member d03b92adc5af7320 is healthy: got healthy result from http://master1:2379
cluster is healthy

[[email protected] etcd]# systemctl enable etcd 
Created symlink from /etc/systemd/system/multi-user.target.wants/etcd.service to /usr/lib/systemd/system/etcd.service.

Master2

[[email protected] etcd]# systemctl start etcd

[[email protected] etcd]# etcdctl -C http://etcd:2379 cluster-health 
member 22a9f7f65563bff5 is healthy: got healthy result from http://master2:2379
member d03b92adc5af7320 is healthy: got healthy result from http://master1:2379
cluster is healthy

[[email protected] etcd]# etcdctl -C http://etcd:4001 cluster-health
member 22a9f7f65563bff5 is healthy: got healthy result from http://master2:2379
member d03b92adc5af7320 is healthy: got healthy result from http://master1:2379
cluster is healthy

[[email protected] etcd]# systemctl enable etcd
Created symlink from /etc/systemd/system/multi-user.target.wants/etcd.service to /usr/lib/systemd/system/etcd.service.

部署 master

安装 docker ,设置开机自启动并开启服务

分别在 master1和master2上面安装docker服务

[root@master1 etcd]# yum install docker -y  
[root@master1 etcd]# chkconfig docker on  
[root@master1 etcd]# systemctl start docker.service  
安装kubernets
yum install kubernetes -y

master 的虚机上,需要运行三个组件:Kubernets API Server、Kubernets Controller Manager、Kubernets Scheduler。

首先修改 /etc/kubernetes/apiserver 文件:

[[email protected] kubernetes]# vim apiserver

###  
# kubernetes system config  
#  
# The following values are used to configure the kube-apiserver  
#  

# The address on the local server to listen to.  
KUBE_API_ADDRESS="--insecure-bind-address=0.0.0.0"

# The port on the local server to listen on.  
KUBE_API_PORT="--port=8080"

# Port minions listen on  
# KUBELET_PORT="--kubelet-port=10250"  

# Comma separated list of nodes in the etcd cluster  
KUBE_ETCD_SERVERS="--etcd-servers=http://etcd:2379"

# Address range to use for services  
KUBE_SERVICE_ADDRESSES="--service-cluster-ip-range=10.254.0.0/16"

# default admission control policies  
# KUBE_ADMISSION_CONTROL="--admission-control=NamespaceLifecycle,NamespaceExists,LimitRanger,SecurityContextDeny,ServiceAccount,ResourceQuota"  
KUBE_ADMISSION_CONTROL="--admission-control=NamespaceLifecycle,NamespaceExists,LimitRanger,SecurityContextDeny,ResourceQuota"

# Add your own!  
KUBE_API_ARGS=""

接着修改 /etc/kubernetes/config 文件:(最后一句 masterX:8080 ,对应master1/2机器就好)

[[email protected] ~]# vim /etc/kubernetes/config

###
# kubernetes system config  
#  
# The following values are used to configure various aspects of all  
# kubernetes services, including  
#  
#   kube-apiserver.service  
#   kube-controller-manager.service  
#   kube-scheduler.service  
#   kubelet.service  
#   kube-proxy.service  
# logging to stderr means we get it in the systemd journal  
KUBE_LOGTOSTDERR="--logtostderr=true"  
  
# journal message level, 0 is debug  
KUBE_LOG_LEVEL="--v=0"  
  
# Should this cluster be allowed to run privileged docker containers  
KUBE_ALLOW_PRIV="--allow-privileged=false"  
  
# How the controller-manager, scheduler, and proxy find the apiserver  
KUBE_MASTER="--master=http://master1:8080" 

修改完成后,启动服务并设置开机自启动即可:

systemctl enable kube-apiserver  
systemctl start kube-apiserver  
systemctl enable kube-controller-manager  
systemctl start kube-controller-manager  
systemctl enable kube-scheduler  
systemctl start kube-scheduler  

部署 node

安装 docker ,设置开机自启动并开启服务
yum install docker -y  
chkconfig docker on  
systemctl start docker.service
安装 kubernetes
yum install kubernetes -y

在 node 的虚机上,需要运行三个组件:Kubelet、Kubernets Proxy。

首先修改 /etc/kubernetes/config 文件:(注意:这里配置的是etcd的地址,也就是master1/2的地址其中之一)

[[email protected] ~]# vim /etc/kubernetes/config

###
# kubernetes system config  
#  
# The following values are used to configure various aspects of all  
# kubernetes services, including  
#  
#   kube-apiserver.service  
#   kube-controller-manager.service  
#   kube-scheduler.service  
#   kubelet.service  
#   kube-proxy.service  
# logging to stderr means we get it in the systemd journal  
KUBE_LOGTOSTDERR="--logtostderr=true"  
  
# journal message level, 0 is debug  
KUBE_LOG_LEVEL="--v=0"  
  
# Should this cluster be allowed to run privileged docker containers
KUBE_ALLOW_PRIV="--allow-privileged=false"  
  
# How the controller-manager, scheduler, and proxy find the apiserver  
KUBE_MASTER="--master=http://etcd:8080"

接着修改 /etc/kubernetes/kubelet 文件:(注:–hostname-override= 对应的node机器

[[email protected] ~]# vim /etc/kubernetes/kubelet

###  
# kubernetes kubelet (minion) config  
  
# The address for the info server to serve on (set to 0.0.0.0 or "" for all interfaces)  
KUBELET_ADDRESS="--address=0.0.0.0"  
  
# The port for the info server to serve on  
# KUBELET_PORT="--port=10250"  
  
# You may leave this blank to use the actual hostname  
KUBELET_HOSTNAME="--hostname-override=node1"  
  
# location of the api-server  
KUBELET_API_SERVER="--api-servers=http://etcd:8080"  
  
# pod infrastructure container  
KUBELET_POD_INFRA_CONTAINER="--pod-infra-container-image=registry.access.redhat.com/rhel7/pod-infrastructure:latest"  
  
# Add your own!  
KUBELET_ARGS=""  

修改完成后,启动服务并设置开机自启动即可:

systemctl enable kubelet  
systemctl start kubelet  
systemctl enable kube-proxy  
systemctl start kube-proxy 

查看集群状态

在任意一台master上查看集群中节点及节点状态:

[root@master1 kubernetes]# kubectl get node
NAME      STATUS    AGE
node1     Ready     1m
node2     Ready     1m

至此,已经搭建了一个kubernetes集群了,但目前该集群还不能很好的工作,因为需要对集群中pod的网络进行统一管理。

创建覆盖网络 flannel

在master、node上均执行如下命令,安装 flannel

yum install flannel -y  

在master、node上均编辑 /etc/sysconfig/flanneld 文件

[[email protected] kubernetes]# vim /etc/sysconfig/flanneld

# Flanneld configuration options    
  
# etcd url location.  Point this to the server where etcd runs  
FLANNEL_ETCD_ENDPOINTS="http://etcd:2379"  
  
# etcd config key.  This is the configuration key that flannel queries  
# For address range assignment  
FLANNEL_ETCD_PREFIX="/atomic.io/network"  
  
# Any additional options that you want to pass  
#FLANNEL_OPTIONS=""  

flannel使用etcd进行配置,来保证多个flannel实例之间的配置一致性,所以需要在etcd上进行如下配置:

etcdctl mk /atomic.io/network/config '{ "Network": "10.0.0.0/16" }'

(‘/atomic.io/network/config’这个key与上文/etc/sysconfig/flannel中的配置项FLANNEL_ETCD_PREFIX是相对应的,错误的话启动就会出错)

启动修改后的 flannel ,并依次重启docker、kubernete

master 虚机上执行:

systemctl enable flanneld  
systemctl start flanneld  
service docker restart  
systemctl restart kube-apiserver  
systemctl restart kube-controller-manager  
systemctl restart kube-scheduler 

node 虚机上执行:

systemctl enable flanneld  
systemctl start flanneld  
service docker restart  
systemctl restart kubelet  
systemctl restart kube-proxy 

这样etcd集群 + flannel + kubernetes集群 在centOS7上就搭建起来了。

不吃貓的鱼oo回答于

安装前准备

操作系统详情

需要三台主机,都最小化安装 centos7.1,并update到最新,详情见如下表格

角色

主机名

IP

Master

master

192.168.0.79

Minion1

minion-1

192.168.0.80

Minion2

minion-2

192.168.0.81

在每台主机上关闭firewalld改用iptables

输入以下命令,关闭firewalld

复制

# systemctl stop firewalld.service    #停止firewall
# systemctl disable firewalld.service #禁止firewall开机启动

然后安装iptables并启用

复制

# yum install -y iptables-services     #安装
# systemctl start iptables.service  #最后重启防火墙使配置生效
# systemctl enable iptables.service #设置防火墙开机启动

安装ntp服务

复制

# yum install -y ntp
# systemctl start ntpd
# systemctl enable ntpd

安装配置

注:kubernetes,etcd等已经进入centos epel源,可以直接yum安装(需要安装epel-release)

安装 Kubernetes Master

1. 使用以下命令安装kubernetes 和 etcd

复制

# yum install -y kubernetes etcd

2. 编辑/etc/etcd/etcd.conf 使etcd监听所有的ip地址,确保下列行没有注释,并修改为下面的值

复制

# vim /etc/etcd/etcd.conf
# [member]
ETCD_NAME=default
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_CLIENT_URLS="<span style="color: #ff0000;">http://0.0.0.0:2379</span>"
#[cluster]
ETCD_ADVERTISE_CLIENT_URLS="http://localhost:2379"

3. 编辑Kubernetes API server的配置文件

确保下列行没有被注释,并为下列的值

复制

# vim /etc/kubernetes/apiserver
###
# kubernetes system config
#
# The following values are used to configure the kube-apiserver
#

# The address on the local server to listen to.
KUBE_API_ADDRESS="--address=0.0.0.0"

# The port on the local server to listen on.
KUBE_API_PORT="--port=8080"

# Port minions listen on
KUBELET_PORT="--kubelet_port=10250"

# Comma separated list of nodes in the etcd cluster
KUBE_ETCD_SERVERS="--etcd_servers=http://127.0.0.1:2379"

# Address range to use for services
KUBE_SERVICE_ADDRESSES="--service-cluster-ip-range=10.254.0.0/16"

# default admission control policies
KUBE_ADMISSION_CONTROL="--admission_control=NamespaceLifecycle,NamespaceExists,LimitRanger,SecurityContextDeny,ServiceAccount,ResourceQuota"

# Add your own!
KUBE_API_ARGS=""

4. 启动etcd, kube-apiserver, kube-controller-manager 和 kube-scheduler服务,并设置开机自启

复制

# for SERVICES in etcd kube-apiserver kube-controller-manager kube-scheduler; do 
    systemctl restart $SERVICES
    systemctl enable $SERVICES
    systemctl status $SERVICES 
done

5. 在etcd中定义flannel network的配置,这些配置会被flannel service下发到minions:

复制

# etcdctl mk /coreos.com/network/config '{"Network":"172.17.0.0/16"}'

6. 添加iptables规则,允许相应的端口

复制

iptables -I INPUT -p tcp --dport 2379 -j ACCEPT
iptables -I INPUT -p tcp --dport 10250 -j ACCEPT
iptables -I INPUT -p tcp --dport 8080 -j ACCEPT
iptables-save

7. 查看节点信息(我们还没有配置节点信息,所以这里应该为空)

复制

# kubectl get nodes
NAME             LABELS              STATUS

安装Kubernetes Minions (Nodes)

注:下面这些步骤应该在minion1和minions2上执行(也可以添加更多的minions)

1. 使用yum安装kubernetes 和 flannel

复制

# yum install -y flannel kubernetes

2. 为flannel service配置etcd服务器

编辑/etc/sysconfig/flanneld文件中的下列行以连接到master

复制

# vim /etc/sysconfig/flanneld

FLANNEL_ETCD="http://192.168.0.79:2379"        #改为etcd服务器的ip

3. 编辑 kubernetes 配置文件

编辑/etc/kubernetes/config中kubernetes的默认配置,确保KUBE_MASTER的值是连接到Kubernetes master API server:

复制

# vim /etc/kubernetes/config
KUBE_MASTER="--master=http://192.168.0.79:8080"

4. 编辑/etc/kubernetes/kubelet 如下行:

minion1:

复制

# vim /etc/kubernetes/kubelet

KUBELET_ADDRESS="--address=0.0.0.0"
KUBELET_PORT="--port=10250"
KUBELET_HOSTNAME="--hostname_override=192.168.0.80"
KUBELET_API_SERVER="--api_servers=http://192.168.0.79:8080"
KUBELET_ARGS=""

minion2:

复制

# vim /etc/kubernetes/kubelet

KUBELET_ADDRESS="--address=0.0.0.0"
KUBELET_PORT="--port=10250"
KUBELET_HOSTNAME="--hostname_override=192.168.0.81"
KUBELET_API_SERVER="--api_servers=http://192.168.0.79:8080"
KUBELET_ARGS=""

5. 启动kube-proxy, kubelet, docker 和 flanneld services服务,并设置开机自启

复制

# for SERVICES in kube-proxy kubelet docker flanneld; do 
    systemctl restart $SERVICES
    systemctl enable $SERVICES
    systemctl status $SERVICES 
done

6. 在每个minion节点,你应当注意到你有两块新的网卡docker0 和 flannel0。你应该得到不同的ip地址范围在flannel0上,就像下面这样:

minion1:

复制

# ip a | grep flannel | grep inet
    inet 172.17.29.0/16 scope global flannel0

minion2:

复制

# ip a | grep flannel | grep inet
    inet 172.17.37.0/16 scope global flannel0

7. 添加iptables规则:

复制

iptables -I INPUT -p tcp --dport 2379 -j ACCEPT
iptables -I INPUT -p tcp --dport 10250 -j ACCEPT
iptables -I INPUT -p tcp --dport 8080 -j ACCEPT

8. 现在登陆kubernetes master节点验证minions的节点状态:

复制

# kubectl get nodes
NAME           LABELS                                STATUS
192.168.0.80   kubernetes.io/hostname=192.168.0.80   Ready
192.168.0.81   kubernetes.io/hostname=192.168.0.81   Ready

至此,kubernetes集群已经配置并运行了,我们可以继续下面的步骤。

创建 Pods (Containers)

为了创建一个pod,我们需要在kubernetes master上面定义一个yaml 或者 json配置文件。然后使用kubectl命令创建pod

复制

# mkdir -p k8s/pods
# cd k8s/pods/
# vim nginx.yaml

在nginx.yaml里面增加如下内容:

复制

apiVersion: v1
kind: Pod
metadata:
  name: nginx
  labels:
    app: nginx
spec:
  containers:
  - name: nginx
    image: nginx
    ports:
    - containerPort: 80

创建pod:

复制

# kubectl create -f nginx.yaml

此时有如下报错:

复制

Error from server: error when creating "nginx.yaml": Pod "nginx" is forbidden: no API token found for service account default/default, retry after the token is automatically created and added to the service account

解决办法是编辑/etc/kubernetes/apiserver 去除 KUBE_ADMISSION_CONTROL 中的 SecurityContextDeny,ServiceAccount ,并重启kube-apiserver.service服务:

复制

# vim /etc/kubernetes/apiserver
KUBE_ADMISSION_CONTROL="--admission_control=NamespaceLifecycle,NamespaceExists,LimitRanger,ResourceQuota"

# systemctl restart kube-apiserver.service

之后重新创建pod:

复制

# kubectl create -f nginx.yaml
pods/nginx

查看pod:

复制

# kubectl get pod nginx
NAME      READY     STATUS                                            RESTARTS   AGE
nginx     0/1       Image: nginx is not ready on the node   0          34s

这里STATUS一直是这个,创建不成功,下面排错。通过查看pod的描述发现如下错误:

复制

# kubectl describe pod nginx 
Wed, 28 Oct 2015 10:25:30 +0800       Wed, 28 Oct 2015 10:25:30 +0800 1       {kubelet 192.168.0.81}  implicitly required container POD       pulled          Successfully pulled Pod container image "gcr.io/google_containers/pause:0.8.0"
  Wed, 28 Oct 2015 10:25:30 +0800       Wed, 28 Oct 2015 10:25:30 +0800 1       {kubelet 192.168.0.81}  implicitly required container POD       failed          Failed to create docker container with error: no such image
  Wed, 28 Oct 2015 10:25:30 +0800       Wed, 28 Oct 2015 10:25:30 +0800 1       {kubelet 192.168.0.81}                                          failedSync      Error syncing pod, skipping: no such image
  Wed, 28 Oct 2015 10:27:30 +0800       Wed, 28 Oct 2015 10:29:30 +0800 2       {kubelet 192.168.0.81}  implicitly required container POD       failed          Failed to pull image "gcr.io/google_containers/pause:0.8.0": image pull failed for gcr.io/google_containers/pause:0.8.0, this may be because there are no credentials on this request.  details: (API error (500): invalid registry endpoint "http://gcr.io/v0/". HTTPS attempt: unable to ping registry endpoint https://gcr.io/v0/
v2 ping attempt failed with error: Get https://gcr.io/v2/: dial tcp 173.194.72.82:443: i/o timeout

手动ping了一下gcr.io发现无法ping通(可能是被墙了),从网上找到 pause:0.8.0 的镜像,然后再每个minion上导入镜像:

复制

# docker load --input pause-0.8.0.tar

附下载:pause-0.8.0.tar 在执行以下命令即可成功创建pod

复制

# kubectl create -f nginx.yaml
pods/nginx

查看pod

复制

# kubectl get pod nginx
NAME      READY     STATUS                                            RESTARTS   AGE
nginx      1/1             Running                                            0               2
athletesss互联网产品经理回答于

Kubernetes 是 Google 开源的基于 Docker 的容器集群管理系统,通过 yaml 语言写的配置文件,简单快速的就能自动部署好应用环境,支持应用横向扩展,并且可以组织、编排、管理和迁移这些容器化的应用。Kubeadm 是一个可以快速帮助我们创建稳定集群服务的工具,通过它,我们可以在虚拟机、实体机或者云端快速部署一个高可用的集群服务。

用户4045633回答于
用户4034066回答于
相柳

深圳市美奔科技有限公司 · 运维 (已认证)

因为相信,长久相伴— www.8n8k.com回答于

腾讯云上的话,个人推荐直接用TKE,会比较好.腾讯云已经把很多工作做掉了.

扫码关注云+社区