使用 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 vs. ARM64；32 位 vs. 64 位；ARM vs. 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 的家庭实验室，以便在将用户和 SSH authorized_keys 添加到 Ubuntu 镜像之前，将其写入 SD 卡并在 Raspberry Pi 上安装。

配置主机

在 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 命令匹配行尾（用第一个 $ 表示），并将其替换为列出的选项（它实际上是将选项附加到行尾）。

完成这些更改后，应该按照 Kubernetes 的需要配置 Docker 和内核。重启 Raspberry Pi，当它们重新启动后，再次检查 docker info 的输出。Cgroups 驱动程序现在是 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 网络所需的 ClusterRole、ServiceAccount 和 DaemonSet（等）。

下载并将 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、创建部署和作业等。您可以使用 Service 从集群中的任何节点访问在集群中运行的应用程序。您可以使用 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 的内部工作正常。

现在，创建一个 Service 以公开在三个 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 服务已被分配了一个 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 控制器将集群中的服务暴露给外部世界。我还将研究动态存储配置器和 StorageClass，用于为应用程序分配持久存储，包括利用您在上一篇文章 将您的 Raspberry Pi 家庭实验室变成网络文件系统 中设置的 NFS 服务器，为您的 Pod 创建按需存储。

前进，Kubernetes 吧

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

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

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

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

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

接下来阅读什么