使用 Raspberry Pi 构建 Kubernetes 集群

在多个 Raspberry Pi 上安装 Kubernetes，打造您自己的“家庭私有云”容器服务。

Coding the Raspberry Pi in a web emulator

图片来源：

Opensource.com

Kubernetes 是一个企业级容器编排系统，从一开始就被设计为云原生。它已发展成为事实上的云容器平台，并在拥抱包括容器原生虚拟化和无服务器计算等新技术的同时不断扩展。

Kubernetes 管理容器以及更多内容，从边缘的微规模到公共云和私有云环境中的大规模。对于“家庭私有云”项目来说，它是一个完美的选择，它既提供了强大的容器编排，又提供了学习一项需求旺盛且与云深度集成的技术的机会，以至于它的名字实际上已成为“云计算”的代名词。

没有什么比 Kubernetes 更能代表“云”，也没有什么比 Raspberry Pi 更能呼唤“集群化”了。在廉价的 Raspberry Pi 硬件上运行本地 Kubernetes 集群是获得管理和开发真正云技术巨头经验的好方法。

在 Raspberry Pi 上安装 Kubernetes 集群

本练习将在三台或更多运行 Ubuntu 20.04 的 Raspberry Pi 4 上安装 Kubernetes 1.18.2 集群。Ubuntu 20.04 (Focal Fossa) 提供了一个 Raspberry Pi 重点关注的 64 位 ARM (ARM64) 镜像，其中包含 64 位内核和用户空间。由于目标是使用这些 Raspberry Pi 运行 Kubernetes 集群，因此运行 AArch64 容器镜像的能力非常重要：很难找到常用软件甚至标准基础镜像的 32 位镜像。凭借其 ARM64 镜像，Ubuntu 20.04 允许您将 64 位容器镜像与 Kubernetes 一起使用。

AArch64 与 ARM64；32 位与 64 位；ARM 与 x86

请注意，AArch64 和 ARM64 实际上是同一件事。名称的不同源于它们在不同社区中的使用。许多容器镜像被标记为 AArch64，并且可以在标记为 ARM64 的系统上正常运行。具有 AArch64/ARM64 架构的系统能够运行 32 位 ARM 镜像，但反之则不然：32 位 ARM 系统无法运行 64 位容器镜像。这就是 Ubuntu 20.04 ARM64 镜像如此有用的原因。

在不深入解释不同架构类型的情况下，值得注意的是 ARM64/AArch64 和 x86_64 架构是不同的，并且在 64 位 ARM 架构上运行的 Kubernetes 节点无法运行为 x86_64 构建的容器镜像。在实践中，您会发现一些镜像不是为这两种架构构建的，可能无法在您的集群中使用。您还需要在基于 AArch64 的系统上构建自己的镜像，或者想方设法让您的常规 x86_64 系统构建 AArch64 镜像。在“家庭私有云”项目的未来文章中，我将介绍如何在您的常规系统上构建 AArch64 镜像。

为了兼顾两者，在本教程中设置 Kubernetes 集群后，您可以稍后向其添加 x86_64 节点。您可以使用 Kubernetes 调度程序的 Kubernetes 污点和容忍度，将给定架构的镜像调度到相应的节点上运行。

关于架构和镜像就说这么多。现在是安装 Kubernetes 的时候了，开始行动吧！

要求

本练习的要求非常低。您将需要

三台（或更多）Raspberry Pi 4（最好是 4GB RAM 型号）
在所有 Raspberry Pi 上安装 Ubuntu 20.04 ARM64

为了简化初始设置，请阅读 修改磁盘镜像以创建基于 Raspberry Pi 的家庭实验室，以便在将 Ubuntu 镜像写入 SD 卡并安装到 Raspberry Pi 之前，向其添加用户和 SSH authorized_keys。

配置主机

一旦在 Raspberry Pi 上安装了 Ubuntu 并且可以通过 SSH 访问它们，您需要在安装 Kubernetes 之前进行一些更改。

安装和配置 Docker

在撰写本文时，Ubuntu 20.04 在基本存储库中发布了最新版本的 Docker v19.03，可以使用 apt 命令直接安装。请注意，软件包名称是 docker.io。在所有 Raspberry Pi 上安装 Docker

# Install the docker.io package
$ sudo apt install -y docker.io

安装软件包后，您需要进行一些更改以启用 cgroups（控制组）。Cgroups 允许 Linux 内核限制和隔离资源。实际上，这允许 Kubernetes 更好地管理其运行的容器使用的资源，并通过将容器彼此隔离来提高安全性。

在对所有 RPi 进行以下更改之前，检查 docker info 的输出

# Check `docker info`
# Some output omitted
$ sudo docker info
(...)
 Cgroup Driver: cgroups
(...)
WARNING: No memory limit support
WARNING: No swap limit support
WARNING: No kernel memory limit support
WARNING: No kernel memory TCP limit support
WARNING: No oom kill disable support

上面的输出突出显示了需要更改的部分：cgroup 驱动程序和限制支持。

首先，将 Docker 使用的默认 cgroups 驱动程序从 cgroups 更改为 systemd，以允许 systemd 充当 cgroups 管理器，并确保只使用一个 cgroup 管理器。这有助于系统稳定性，并且是 Kubernetes 推荐的。为此，创建或替换 /etc/docker/daemon.json 文件，内容如下：

# Create or replace the contents of /etc/docker/daemon.json to enable the systemd cgroup driver

$ sudo cat > /etc/docker/daemon.json <<EOF
{
  "exec-opts": ["native.cgroupdriver=systemd"],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m"
  },
  "storage-driver": "overlay2"
}
EOF

启用 cgroups 限制支持

接下来，启用限制支持，如上面的 docker info 输出中的警告所示。您需要修改内核命令行以在启动时启用这些选项。对于 Raspberry Pi 4，将以下内容添加到 /boot/firmware/cmdline.txt 文件中

cgroup_enable=cpuset
cgroup_enable=memory
cgroup_memory=1
swapaccount=1

确保将它们添加到 cmdline.txt 文件中的行尾。可以使用 sed 在一行中完成此操作

# Append the cgroups and swap options to the kernel command line
# Note the space before "cgroup_enable=cpuset", to add a space after the last existing item on the line
$ sudo sed -i '$ s/$/ cgroup_enable=cpuset cgroup_enable=memory cgroup_memory=1 swapaccount=1/' /boot/firmware/cmdline.txt

sed 命令匹配行的终止符（用第一个 $ 表示），并将其替换为列出的选项（它有效地将选项附加到行尾）。

通过这些更改，Docker 和内核应该已配置为 Kubernetes 所需的状态。重新启动 Raspberry Pi，当它们重新启动后，再次检查 docker info 的输出。Cgroups driver 现在是 systemd，并且警告消失了。

允许 iptables 查看桥接流量

根据文档，Kubernetes 需要配置 iptables 以查看桥接网络流量。您可以通过更改 sysctl 配置来完成此操作

# Enable net.bridge.bridge-nf-call-iptables and -iptables6
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF
$ sudo sysctl --system

安装 Ubuntu 的 Kubernetes 软件包

由于您正在使用 Ubuntu，因此可以从 Kubernetes.io Apt 存储库安装 Kubernetes 软件包。目前没有 Ubuntu 20.04 (Focal) 的存储库，但 Kubernetes 1.18.2 在上一个 Ubuntu LTS 存储库中可用：Ubuntu 18.04 (Xenial)。可以从那里安装最新的 Kubernetes 软件包。

将 Kubernetes 存储库添加到 Ubuntu 的源列表中

# Add the packages.cloud.google.com atp key
$ curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -

# Add the Kubernetes repo
cat <<EOF | sudo tee /etc/apt/sources.list.d/kubernetes.list
deb https://apt.kubernetes.io/ kubernetes-xenial main
EOF

当 Kubernetes 添加 Focal 存储库时——可能在下一个 Kubernetes 版本发布时——请务必切换到它。

将存储库添加到源列表后，安装三个必需的 Kubernetes 软件包：kubelet、kubeadm 和 kubectl

# Update the apt cache and install kubelet, kubeadm, and kubectl
# (Output omitted)
$ sudo apt update && sudo apt install -y kubelet kubeadm kubectl

最后，使用 apt-mark hold 命令禁用这三个软件包的定期更新。Kubernetes 的升级需要比通用更新过程更多的手动操作，并且需要人工干预

# Disable (mark as held) updates for the Kubernetes packages
$ sudo apt-mark hold kubelet kubeadm kubectl
kubelet set on hold.
kubeadm set on hold.
kubectl set on hold.

主机配置到此为止！现在您可以继续设置 Kubernetes 本身了。

创建 Kubernetes 集群

安装 Kubernetes 软件包后，您可以继续创建集群。在开始之前，您需要做出一些决定。首先，需要将其中一个 Raspberry Pi 指定为控制平面（即主）节点。其余节点将被指定为计算节点。

您还需要选择一个网络 CIDR 用于 Kubernetes 集群中的 Pod。在集群创建期间设置 pod-network-cidr 可确保设置 podCIDR 值，并且稍后可以被容器网络接口 (CNI) 插件使用。本练习使用 Flannel CNI。您选择的 CIDR 不应与您家庭网络中当前使用的任何 CIDR 或由您的路由器或 DHCP 服务器管理的 CIDR 重叠。确保使用大于您预期需要的子网：Pod 总是比您最初计划的要多！在本示例中，我将使用 10.244.0.0/16，但请选择适合您的子网。

做出这些决定后，您可以初始化控制平面节点。SSH 或以其他方式登录到您已指定为控制平面的节点。

初始化控制平面

Kubernetes 使用引导令牌来验证加入集群的节点。在初始化控制平面节点时，需要将此令牌传递给 kubeadm init 命令。生成一个令牌以与 kubeadm token generate 命令一起使用

# Generate a bootstrap token to authenticate nodes joining the cluster
$ TOKEN=$(sudo kubeadm token generate)
$ echo $TOKEN
d584xg.xupvwv7wllcpmwjy

现在您可以初始化控制平面了，使用 kubeadm init 命令

# Initialize the Control Plane
# (output omitted)
$ sudo kubeadm init --token=${TOKEN} --kubernetes-version=v1.18.2 --pod-network-cidr=10.244.0.0/16

如果一切顺利，您应该在输出结束时看到类似于以下内容

Your Kubernetes control-plane has initialized successfully!

To start using your cluster, you need to run the following as a regular user:

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

You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  https://kubernetes.ac.cn/docs/concepts/cluster-administration/addons/

Then you can join any number of worker nodes by running the following on each as root:

kubeadm join 192.168.2.114:6443 --token zqqoy7.9oi8dpkfmqkop2p5 \
    --discovery-token-ca-cert-hash sha256:71270ea137214422221319c1bdb9ba6d4b76abfa2506753703ed654a90c4982b

请注意两件事：首先，Kubernetes kubectl 连接信息已写入 /etc/kubernetes/admin.conf。此 kubeconfig 文件可以复制到 ~/.kube/config，无论是 root 用户还是主节点上的普通用户，还是远程计算机。这将允许您使用 kubectl 命令控制您的集群。

其次，输出的最后一行以 kubernetes join 开头，是您可以运行以将更多节点加入集群的命令。

将新的 kubeconfig 复制到您的用户可以使用的位置后，您可以使用 kubectl get nodes 命令验证控制平面是否已安装

# Show the nodes in the Kubernetes cluster
# Your node name will vary
$ kubectl get nodes
NAME         STATUS   ROLES    AGE     VERSION
elderberry   Ready    master   7m32s   v1.18.2

安装 CNI 插件

CNI 插件处理 Pod 网络的配置和清理。如前所述，本练习使用 Flannel CNI 插件。由于 podCIDR 值已设置，您只需下载 Flannel YAML 并使用 kubectl apply 将其安装到集群中即可。可以使用 kubectl apply -f - 从标准输入获取数据，在一行中完成此操作。这将创建管理 Pod 网络所需的 ClusterRoles、ServiceAccounts 和 DaemonSets（等等）。

下载并将 Flannel YAML 数据应用到集群

# Download the Flannel YAML data and apply it
# (output omitted)
$ curl -sSL https://raw.githubusercontent.com/coreos/flannel/v0.12.0/Documentation/kube-flannel.yml | kubectl apply -f -

将计算节点加入集群

CNI 插件就位后，现在是将计算节点添加到集群的时候了。加入计算节点只需运行在 kube init 命令结束时提供的 kubeadm join 命令，该命令用于初始化控制平面节点。对于您要加入集群的其他 Raspberry Pi，请登录到主机并运行该命令

# Join a node to the cluster - your tokens and ca-cert-hash will vary
$ sudo kubeadm join 192.168.2.114:6443 --token zqqoy7.9oi8dpkfmqkop2p5 \
    --discovery-token-ca-cert-hash sha256:71270ea137214422221319c1bdb9ba6d4b76abfa2506753703ed654a90c4982b

在每个节点上完成加入过程后，您应该能够在 kubectl get nodes 的输出中看到新节点

# Show the nodes in the Kubernetes cluster
# Your node name will vary
$ kubectl get nodes
NAME         STATUS   ROLES    AGE     VERSION
elderberry   Ready    master   7m32s   v1.18.2
gooseberry    Ready    <none>   2m39s   v1.18.2
huckleberry   Ready    <none>   17s     v1.18.2

验证集群

此时，您已经拥有一个完全正常运行的 Kubernetes 集群。您可以运行 Pod、创建部署和作业等。您可以使用服务从集群中的任何节点访问集群中运行的应用程序。您可以使用 NodePort 服务或 Ingress 控制器实现外部访问。

为了验证集群是否正在运行，请创建一个新的命名空间、部署和服务，并检查部署中运行的 Pod 是否按预期响应。此部署使用 quay.io/clcollins/kube-verify:01 镜像——一个监听请求的 Nginx 容器（实际上，与 使用 Cloud-init 向您的私有云添加节点 文章中使用的镜像相同）。您可以在此处查看镜像 Containerfile。

创建一个名为 kube-verify 的命名空间用于部署

# Create a new namespace
$ kubectl create namespace kube-verify
# List the namespaces
$ kubectl get namespaces
NAME              STATUS   AGE
default           Active   63m
kube-node-lease   Active   63m
kube-public       Active   63m
kube-system       Active   63m
kube-verify       Active   19s

现在，在新命名空间中创建一个部署

# Create a new deployment
$ cat <<EOF | kubectl create -f -
apiVersion: apps/v1
kind: Deployment
metadata:
  name: kube-verify
  namespace: kube-verify
  labels:
    app: kube-verify
spec:
  replicas: 3
  selector:
    matchLabels:
      app: kube-verify
  template:
    metadata:
      labels:
        app: kube-verify
    spec:
      containers:
      - name: nginx
        image: quay.io/clcollins/kube-verify:01
        ports:
        - containerPort: 8080
EOF
deployment.apps/kube-verify created

Kubernetes 现在将开始创建部署，该部署由三个 Pod 组成，每个 Pod 运行 quay.io/clcollins/kube-verify:01 镜像。大约一分钟后，新的 Pod 应该正在运行，您可以使用 kubectl get all -n kube-verify 查看它们，以列出在新命名空间中创建的所有资源

# Check the resources that were created by the deployment
$ kubectl get all -n kube-verify
NAME                               READY   STATUS              RESTARTS   AGE
pod/kube-verify-5f976b5474-25p5r   0/1     Running             0          46s
pod/kube-verify-5f976b5474-sc7zd   1/1     Running             0          46s
pod/kube-verify-5f976b5474-tvl7w   1/1     Running             0          46s

NAME                          READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/kube-verify   3/3     3            3           47s

NAME                                     DESIRED   CURRENT   READY   AGE
replicaset.apps/kube-verify-5f976b5474   3         3         3       47s

您可以看到新的部署、部署创建的副本集以及副本集创建的三个 Pod，以满足部署中的 replicas: 3 请求。您可以看到 Kubernetes 的内部正在工作。

现在，创建一个服务来公开在三个 Pod 中运行的 Nginx “应用程序”（或者，在本例中是欢迎页面）。这将充当一个单一端点，您可以通过该端点连接到 Pod。

# Create a service for the deployment
$ cat <<EOF | kubectl create -f -
apiVersion: v1
kind: Service
metadata:
  name: kube-verify
  namespace: kube-verify
spec:
  selector:
    app: kube-verify
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
EOF
service/kube-verify created

创建服务后，您可以检查它并获取新服务的 IP 地址

# Examine the new service
$ kubectl get -n kube-verify service/kube-verify
NAME          TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)   AGE
kube-verify   ClusterIP   10.98.188.200   <none>        80/TCP    30s

您可以看到 kube-verify 服务已被分配一个集群内部 IP (ClusterIP) 10.98.188.200。此 IP 可以从您的任何节点访问，但不能从集群外部访问。您可以通过在此 IP 连接到部署中的容器来验证它们是否正在工作

# Use curl to connect to the ClusterIP:
# (output truncated for brevity)
$ curl 10.98.188.200
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>

成功！您的服务正在运行，容器内的 Nginx 正在响应您的请求。

此时，您已经在 Raspberry Pi 上拥有了一个正在运行的 Kubernetes 集群，其中安装了 CNI 插件 (Flannel) 以及一个正在运行 Nginx Web 服务器的测试部署和服务。在大型公有云中，Kubernetes 具有不同的 Ingress 控制器，用于与不同的解决方案进行交互，例如最近介绍的 Skipper 项目。同样，私有云也具有 Ingress 控制器，用于与硬件负载均衡器设备（如 F5 Networks 的负载均衡器）或 Nginx 和 HAProxy 控制器进行交互，以处理进入节点的流量。

在未来的文章中，我将解决通过安装您自己的 Ingress 控制器将集群中的服务公开给外部世界的问题。我还将研究动态存储供应器和 StorageClasses，用于为应用程序分配持久存储，包括利用您在之前的文章 将您的 Raspberry Pi 家庭实验室变成网络文件系统 中设置的 NFS 服务器，为您的 Pod 创建按需存储。

前进，Kubernetes！

“Kubernetes”(κυβερνήτης) 在希腊语中是“飞行员”的意思——但这是否意味着既指引航船的人，也指引航船的行为？嗯，不是。“Kubernan”(κυβερνάω) 在希腊语中是“驾驶”或“掌舵”的意思，所以前进并 Kubernan 吧，如果您在会议或其他场合看到我，请原谅我尝试将名词变成动词。来自另一种语言。我不会说那种语言。

免责声明：如前所述，我不阅读也不说希腊语，尤其是古代希腊语，所以我选择相信我在互联网上看到的东西。您知道这是怎么回事。请持保留态度，并稍微原谅我，因为我没有开“这对我来说就像希腊语一样”的玩笑。但是，仅仅是提到它，我就能够在实际上没有开玩笑的情况下开玩笑，所以我要么是狡猾，要么是聪明，要么两者都是。或者，两者都不是。我没有声称这是一个好笑话。

所以，前进并像专业人士一样驾驶您的容器，在您的家庭私有云中使用您自己的 Kubernetes 容器服务！随着您越来越舒适，您可以修改您的 Kubernetes 集群以尝试不同的选项，例如前面提到的 Ingress 控制器和用于持久卷的动态 StorageClasses。

这种持续学习是 DevOps 的核心，新服务的持续集成和交付反映了敏捷方法，我们都已接受了这两种方法，因为我们已经学会了应对云带来的大规模，并发现我们传统的实践无法跟上步伐。

看看！技术、政策、哲学、一点点希腊语和一个糟糕的元笑话，尽在一篇文章中！

接下来阅读什么