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

配置主机

一旦在 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 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 的内部工作正常。

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

前进，Kubernetes 吧

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

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

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

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

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

接下来阅读什么