👩🏻‍🤝‍👨🏼 🦐 👈🏽 Selesaikan Kubernetes dari awal di Raspberry Pi ☝🏾 🌖 🎼

Baru-baru ini, sebuah perusahaan terkenal mengumumkan bahwa mereka mengalihkan lini laptopnya ke arsitektur ARM. Mendengar berita ini, saya ingat: saat melihat harga EC2 di AWS sekali lagi, saya menarik perhatian ke Gravitons dengan harga yang sangat enak. Tangkapannya, tentu saja, adalah ARM. Bahkan tidak terpikir oleh saya bahwa ARM cukup serius ...

Bagi saya, arsitektur ini selalu menjadi banyak hal seluler dan IoT lainnya. Server "asli" di ARM entah bagaimana tidak biasa, bahkan dalam beberapa hal liar ... Namun, sebuah pemikiran baru melekat di kepala saya, jadi suatu akhir pekan saya memutuskan untuk memeriksa apa yang dapat diluncurkan di ARM hari ini. Dan untuk ini saya memutuskan untuk memulai dengan yang paling dekat - cluster Kubernetes. Dan bukan hanya beberapa "cluster" bersyarat, tetapi semuanya "secara dewasa" sehingga sebanyak mungkin sama seperti yang biasa saya lihat dalam produksi.

Menurut ide saya, cluster harus dapat diakses dari Internet, beberapa aplikasi web harus berjalan di dalamnya dan setidaknya harus ada pemantauan. Untuk mengimplementasikan ide ini, Anda memerlukan sepasang (atau lebih) model Raspberry Pi 3B + atau lebih tinggi. AWS juga bisa menjadi platform untuk eksperimen, tetapi "raspberry" -lah yang menarik bagi saya (yang masih diam). Jadi, kami akan menerapkan cluster Kubernetes dengan Ingress, Prometheus, dan Grafana di dalamnya.

Persiapan "raspberry"

Menginstal OS dan SSH

Saya tidak terlalu repot dengan pilihan OS untuk instalasi: Saya baru saja mengambil Raspberry Pi OS Lite terbaru dari situs resminya . Dokumentasi penginstalan juga tersedia di sana , semua langkah yang harus dilakukan di semua node cluster mendatang. Selanjutnya, Anda perlu melakukan manipulasi berikut (juga pada semua node).

Setelah menghubungkan monitor dan keyboard, Anda harus terlebih dahulu mengkonfigurasi jaringan dan SSH:

Agar cluster berfungsi, master harus memiliki alamat IP statis, dan node yang berfungsi harus memiliki alamat IP statis. Saya lebih suka alamat statis di mana pun untuk kemudahan pengaturan.
Alamat statis dapat dikonfigurasi di OS ( /etc/dhcpcd.confada contoh yang sesuai di file ) atau dengan memperbaiki sewa di server DHCP dari router yang digunakan (dalam kasus saya, rumah).
ssh-server hanya disertakan dalam raspi-config ( opsi antarmuka -> ssh ).

Setelah itu, Anda sudah dapat masuk melalui SSH (secara default, login adalah pi, dan kata sandi adalah yang raspberryAnda ubah) dan melanjutkan pengaturan.

Pengaturan lainnya

Mari tetapkan nama host. Dalam contoh saya, pi-controldan akan digunakan pi-worker.
Mari kita periksa bahwa sistem file diperluas ke seluruh disk ( df -h /). Ini dapat diperpanjang jika perlu menggunakan raspi-config.
Ubah kata sandi pengguna default di raspi-config.
Matikan file swap (ini adalah persyaratan Kubernetes; jika Anda tertarik dengan detail tentang topik ini, lihat masalah # 53533 ):
```
dphys-swapfile swapoff
systemctl disable dphys-swapfile
```
Mari perbarui paket ke versi terbaru:
```
apt-get update && apt-get dist-upgrade -y
```
Instal Docker dan paket tambahan:
```
apt-get install -y docker docker.io apt-transport-https curl bridge-utils iptables-persistent
```
Selama instalasi, Anda iptables-persistentperlu menyimpan pengaturan iptables untuk ipv4, dan /etc/iptables/rules.v4menambahkan aturan ke rantai dalam file FORWARD, seperti ini:
```
# Generated by xtables-save v1.8.2 on Sun Jul 19 00:27:43 2020
*filter
:INPUT ACCEPT [0:0]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
-A FORWARD -s 10.1.0.0/16  -j ACCEPT
-A FORWARD -d 10.1.0.0/16  -j ACCEPT
COMMIT
```
Tetap hanya untuk reboot.

Anda sekarang siap untuk menginstal cluster Kubernetes Anda.

Menginstal Kubernetes

Pada tahap ini, saya sengaja menunda semua perkembangan saya dan perusahaan kami dalam mengotomatiskan instalasi dan konfigurasi cluster K8s. Sebagai gantinya, kami akan menggunakan dokumentasi resmi dari kubernetes.io (sedikit ditambah dengan komentar dan singkatan).

Tambahkan repositori Kubernetes:

curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
cat <<EOF | sudo tee /etc/apt/sources.list.d/kubernetes.list
deb https://apt.kubernetes.io/ kubernetes-xenial main
EOF
sudo apt-get update

Lebih lanjut dalam dokumentasi itu diusulkan untuk menginstal CRI (antarmuka runtime kontainer). Karena Docker sudah diinstal, mari lanjutkan dan instal komponen utama:

sudo apt-get install -y kubelet kubeadm kubectl kubernetes-cni

Pada langkah memasang komponen utama, saya segera menambahkan kubernetes-cniapa yang diperlukan agar cluster berfungsi. Dan di sini ada poin penting: kubernetes-cniuntuk beberapa alasan, paket tidak membuat direktori default untuk pengaturan antarmuka CNI, jadi saya harus membuatnya secara manual:

mkdir -p /etc/cni/net.d

Agar backend jaringan berfungsi, yang akan dibahas di bawah, Anda perlu menginstal plugin untuk CNI. Saya memilih plugin portmap, yang akrab dan jelas bagi saya (lihat dokumentasi untuk daftar lengkapnya ):

curl -sL https://github.com/containernetworking/plugins/releases/download/v0.7.5/cni-plugins-arm-v0.7.5.tgz | tar zxvf - -C /opt/cni/bin/ ./portmap

Mengonfigurasi Kubernetes

Node bidang kontrol

Menyiapkan cluster itu sendiri cukup mudah. Dan untuk mempercepat proses ini dan memverifikasi bahwa image Kubernetes tersedia, Anda dapat menjalankan terlebih dahulu:

kubeadm config images pull

Sekarang kami melakukan instalasi itu sendiri - kami menginisialisasi bidang kontrol cluster:

kubeadm init --pod-network-cidr=10.1.0.0/16 --service-cidr=10.2.0.0/16 --upload-certs

Harap diperhatikan bahwa subnet untuk layanan dan pod tidak boleh tumpang tindih satu sama lain atau dengan jaringan yang ada.

Pada akhirnya, kita akan diperlihatkan pesan yang menyatakan bahwa semuanya baik-baik saja, dan pada saat yang sama mereka akan memberi tahu Anda cara memasang node kerja ke bidang kontrol:

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.io/docs/concepts/cluster-administration/addons/
You can now join any number of the control-plane node running the following command on each as root:
 kubeadm join 192.168.88.30:6443 --token a485vl.xjgvzzr2g0xbtbs4 \
   --discovery-token-ca-cert-hash sha256:9da6b05aaa5364a9ec59adcc67b3988b9c1b94c15e81300560220acb1779b050 \
   --contrl-plane --certificate-key 72a3c0a14c627d6d7fdade1f4c8d7a41b0fac31b1faf0d8fdf9678d74d7d2403
Please note that the certificate-key gives access to cluster sensitive data, keep it secret!
As a safeguard, uploaded-certs will be deleted in two hours; If necessary, you can use
"kubeadm init phase upload-certs --upload-certs" to reload certs afterward.
Then you can join any number of worker nodes by running the following on each as root:
kubeadm join 192.168.88.30:6443 --token a485vl.xjgvzzr2g0xbtbs4 \
   --discovery-token-ca-cert-hash sha256:9da6b05aaa5364a9ec59adcc67b3988b9c1b94c15e81300560220acb1779b050

Mari ikuti rekomendasi untuk menambahkan konfigurasi untuk pengguna. Dan pada saat yang sama, saya merekomendasikan untuk menambahkan pelengkapan otomatis untuk kubectl segera:

 kubectl completion bash > ~/.kube/completion.bash.inc
 printf "
 # Kubectl shell completion
 source '$HOME/.kube/completion.bash.inc'
 " >> $HOME/.bash_profile
 source $HOME/.bash_profile

Pada tahap ini, Anda sudah bisa melihat node pertama di cluster (meskipun belum siap):

root@pi-control:~# kubectl get no
NAME         STATUS     ROLES    AGE   VERSION
pi-control   NotReady   master   29s   v1.18.6

Konfigurasi jaringan

Selanjutnya, seperti yang dikatakan dalam pesan setelah instalasi, Anda perlu menginstal jaringan ke dalam cluster. Dokumentasi menawarkan pilihan Calico, Cilium, contiv-vpp, Kube-router dan Weave Net ... Di sini saya menyimpang dari instruksi resmi dan memilih opsi yang lebih familiar dan mudah dimengerti bagi saya: flanel dalam mode host-gw (untuk informasi lebih lanjut tentang backend yang tersedia, lihat dokumentasinya proyek ).

Menginstalnya ke dalam cluster cukup sederhana. Pertama, unduh manifes:

wget https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

Kemudian ubah jenis dari vxlanmenjadi di pengaturan host-gw:

sed -i 's/vxlan/host-gw/' kube-flannel.yml

... dan subnet pod - dari nilai default ke nilai yang ditentukan selama inisialisasi cluster:

sed -i 's#10.244.0.0/16#10.1.0.0/16#' kube-flannel.yml

Setelah itu, kami membuat sumber daya:

kubectl create -f kube-flannel.yml

Selesai! Setelah beberapa saat, node K8 pertama akan berstatus Ready:

NAME         STATUS   ROLES    AGE   VERSION
pi-control   Ready    master   2m    v1.18.6

Menambahkan node pekerja

Sekarang Anda dapat menambahkan pekerja. Untuk melakukan ini, setelah menginstal Kubernetes sendiri sesuai dengan skenario yang dijelaskan di atas, Anda hanya perlu menjalankan perintah yang diterima sebelumnya:

kubeadm join 192.168.88.30:6443 --token a485vl.xjgvzzr2g0xbtbs4 \
    --discovery-token-ca-cert-hash sha256:9da6b05aaa5364a9ec59adcc67b3988b9c1b94c15e81300560220acb1779b050

Dalam hal ini kita dapat berasumsi bahwa cluster sudah siap:

root@pi-control:~# kubectl get no
NAME         STATUS   ROLES    AGE    VERSION
pi-control   Ready    master   28m    v1.18.6
pi-worker    Ready    <none>   2m8s   v1.18.6

Saya hanya memiliki dua Raspberry Pi, jadi saya tidak ingin memberikan salah satunya di bawah bidang kendali. Jadi saya menghapus noda yang diinstal otomatis dari node pi-control dengan menjalankan:

root@pi-control:~# kubectl edit node pi-control

... dan menghapus garis:

 - effect: NoSchedule
   key: node-role.kubernetes.io/master

Mengisi cluster dengan jumlah minimum yang dibutuhkan

Pertama-tama kita membutuhkan Helm . Tentu saja, Anda dapat melakukan semuanya tanpa itu, tetapi Helm memungkinkan Anda untuk menyesuaikan beberapa komponen sesuai kebijaksanaan Anda secara harfiah tanpa mengedit file. Dan sebenarnya itu hanya file biner yang "tidak meminta roti".

Jadi, buka helm.sh di bagian docs / installation dan jalankan perintah dari sana:

curl -s https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3 | bash

Setelah itu tambahkan repositori grafik:

helm repo add stable https://kubernetes-charts.storage.googleapis.com/

Sekarang mari kita pasang komponen infrastruktur sesuai dengan idenya:

Pengontrol masuk;
Prometheus;
Grafana;
manajer sertifikat.

Pengontrol masuk

Komponen pertama, pengontrol Ingress , mudah dipasang dan siap digunakan di luar kotak. Untuk melakukan ini, cukup buka bagian bare-metal di situs dan jalankan perintah instalasi dari sana:

kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v0.34.1/deploy/static/provider/baremetal/deploy.yaml

Namun, pada saat ini, "raspberry" mulai membebani dan menjalankan IOPS disk. Faktanya adalah bahwa bersama dengan pengontrol Ingress, sejumlah besar sumber daya diinstal, banyak permintaan API dibuat, dan, karenanya, banyak data ditulis ke etcd. Secara umum, baik kartu memori kelas 10 tidak terlalu produktif, atau kartu SD pada dasarnya tidak cukup untuk beban seperti itu. Namun demikian, setelah 5 menit semuanya dimulai.

Namespace telah dibuat dan pengontrol muncul di dalamnya dan semua yang dibutuhkannya:

root@pi-control:~# kubectl -n ingress-nginx get pod
NAME                                        READY   STATUS      RESTARTS   AGE
ingress-nginx-admission-create-2hwdx        0/1     Completed   0          31s
ingress-nginx-admission-patch-cp55c         0/1     Completed   0          31s
ingress-nginx-controller-7fd7d8df56-68qp5   1/1     Running     0          48s

Prometheus

Dua komponen berikutnya cukup mudah dipasang melalui Helm dari grafik repo.

Temukan Prometheus , buat namespace dan instal di dalamnya:

helm search repo stable | grep prometheus
kubectl create ns monitoring
helm install prometheus --namespace monitoring stable/prometheus --set server.ingress.enabled=True --set server.ingress.hosts={"prometheus.home.pi"}

Secara default, Prometheus memesan 2 disk: untuk data Prometheus dan untuk data AlertManager. Karena tidak ada kelas penyimpanan yang dibuat dalam cluster, disk tidak akan dipesan dan pod tidak akan dimulai. Untuk instalasi Kubernetes logam kosong, kami biasanya menggunakan Ceph rbd, tetapi dalam kasus Raspberry Pi, ini berlebihan.

Jadi mari kita buat penyimpanan lokal sederhana di hostpath. Manifes PV (volume persisten) untuk prometheus-server dan prometheus-alertmanager digabungkan dalam sebuah file prometheus-pv.yamldi repositori Git dengan contoh untuk artikel tersebut . Direktori untuk PV harus dibuat terlebih dahulu pada disk node tempat kita ingin mengikat Prometheus: dalam contoh nodeAffinity, nama host ditentukan pi-workerdan direktori /data/localstorage/prometheus-serverserta dibuat di atasnya /data/localstorage/prometheus-alertmanager.

Unduh (kloning) manifes dan tambahkan ke Kubernetes:

kubectl create -f prometheus-pv.yaml

Pada tahap ini, saya pertama kali mengalami masalah arsitektur ARM. Kube-state-metrics, yang disetel secara default di bagan Prometheus, menolak untuk memulai. Itu membuat kesalahan:

root@pi-control:~# kubectl -n monitoring logs prometheus-kube-state-metrics-c65b87574-l66d8
standard_init_linux.go:207: exec user process caused "exec format error"

Faktanya adalah untuk kube-state-metrics, gambar proyek CoreOS digunakan, yang tidak dibuat untuk ARM:

kubectl -n monitoring get deployments.apps prometheus-kube-state-metrics -o=jsonpath={.spec.template.spec.containers[].image}
quay.io/coreos/kube-state-metrics:v1.9.7

Saya harus sedikit mencari di Google dan menemukan, misalnya, gambar ini . Untuk memanfaatkannya, mari perbarui rilisnya, dengan menentukan gambar mana yang akan digunakan untuk kube-state-metrics:

helm upgrade prometheus --namespace monitoring stable/prometheus --set server.ingress.enabled=True --set server.ingress.hosts={"prometheus.home.pi"} --set kube-state-metrics.image.repository=carlosedp/kube-state-metrics --set kube-state-metrics.image.tag=v1.9.6

Kami memeriksa bahwa semuanya telah dimulai:

root@pi-control:~# kubectl -n monitoring get po
NAME                                             READY   STATUS              RESTARTS   AGE
prometheus-alertmanager-df65d99d4-6d27g          2/2     Running             0          5m56s
prometheus-kube-state-metrics-5dc5fd89c6-ztmqr   1/1     Running             0          5m56s
prometheus-node-exporter-49zll                   1/1     Running             0          5m51s
prometheus-node-exporter-vwl44                   1/1     Running             0          4m20s
prometheus-pushgateway-c547cfc87-k28qx           1/1     Running             0          5m56s
prometheus-server-85666fd794-z9qnc               2/2     Running             0          4m52s

Grafana dan manajer sertifikat

Untuk bagan dan dasbor, instal Grafana :

helm install grafana --namespace monitoring stable/grafana  --set ingress.enabled=true --set ingress.hosts={"grafana.home.pi"}

Di akhir keluaran, kita akan ditunjukkan bagaimana mendapatkan kata sandi untuk akses:

kubectl get secret --namespace monitoring grafana -o jsonpath="{.data.admin-password}" | base64 --decode ; echo

Untuk memesan sertifikat, instal manajer-sertifikat . Untuk menginstalnya, lihat dokumentasinya , yang menawarkan perintah yang sesuai untuk Helm:

helm repo add jetstack https://charts.jetstack.io

helm install \
  cert-manager jetstack/cert-manager \
  --namespace cert-manager \
  --version v0.16.0 \
  --set installCRDs=true

Untuk sertifikat yang ditandatangani sendiri di rumah, ini sudah cukup. Jika Anda perlu menerima Let's Encrypt yang sama , maka Anda perlu mengonfigurasi penerbit cluster lain. Detail selengkapnya dapat ditemukan di artikel kami " Sertifikat SSL dari Let's Encrypt with cert-manager di Kubernetes ".

Saya sendiri memilih varian dari contoh dalam dokumentasi , memutuskan bahwa varian LE pementasan sudah cukup. Ubah email dalam contoh, simpan ke file dan tambahkan ke cluster ( cert-manager-cluster-Issuer.yaml ):

kubectl create -f cert-manager-cluster-issuer.yaml

Sekarang Anda bisa memesan sertifikat, misalnya untuk Grafana. Ini akan membutuhkan domain dan akses eksternal ke cluster. Saya memiliki domain, dan saya mengonfigurasi lalu lintas dengan meneruskan port 80 dan 443 di router rumah saya sesuai dengan layanan pengontrol masuk yang dibuat:

kubectl -n ingress-nginx get svc
NAME                                 TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)                      AGE
ingress-nginx-controller             NodePort    10.2.206.61    <none>        80:31303/TCP,443:30498/TCP   23d

Porta ke-80 dalam hal ini diterjemahkan ke 31303, dan 443 ke 30498. (Port dibuat secara acak, jadi Anda akan memiliki port yang berbeda.)

Berikut adalah contoh sertifikat ( cert-manager-grafana-certificate.yaml ):

apiVersion: cert-manager.io/v1alpha2
kind: Certificate
metadata:
  name: grafana
  namespace: monitoring
spec:
  dnsNames:
    - grafana.home.pi
  secretName: grafana-tls
  issuerRef:
    kind: ClusterIssuer
    name: letsencrypt-staging

Tambahkan ke cluster:

kubectl create -f cert-manager-grafana-certificate.yaml

Setelah itu, sumber daya Ingress akan muncul, di mana validasi Let's Encrypt akan dilakukan:

root@pi-control:~# kubectl -n monitoring get ing
NAME                        CLASS    HOSTS                        ADDRESS         PORTS   AGE
cm-acme-http-solver-rkf8l   <none>   grafana.home.pi      192.168.88.31   80      72s
grafana                     <none>   grafana.home.pi      192.168.88.31   80      6d17h
prometheus-server           <none>   prometheus.home.pi   192.168.88.31   80      8d

Setelah validasi berlalu, kita akan melihat bahwa sumber daya sudah certificatesiap, dan rahasia di atas berisi grafana-tlssertifikat dan kunci. Anda bisa langsung mengecek siapa yang menerbitkan sertifikat:

root@pi-control:~# kubectl -n monitoring get certificate
NAME      READY   SECRET        AGE
grafana   True    grafana-tls   13m

root@pi-control:~# kubectl -n monitoring get secrets grafana-tls -ojsonpath="{.data['tls\.crt']}" | base64 -d | openssl x509 -issuer -noout
issuer=CN = Fake LE Intermediate X1

Ayo kembali ke Grafana. Kita perlu sedikit memperbaiki rilis Helm-nya, mengubah pengaturan TLS sesuai dengan sertifikat yang dihasilkan.

Untuk melakukan ini, unduh grafik, edit dan perbarui dari direktori lokal:

helm pull --untar stable/grafana

Edit grafana/values.yaml parameter TLS di file :

  tls:
    - secretName: grafana-tls
      hosts:
        - grafana.home.pi

Di sini Anda dapat segera mengkonfigurasi Prometheus yang diinstal sebagai datasource:

datasources:
  datasources.yaml:
    apiVersion: 1
    datasources:
    - name: Prometheus
      type: prometheus
      url: http://prometheus-server:80
      access: proxy
      isDefault: true

Sekarang perbarui grafik Grafana dari direktori lokal:

helm upgrade grafana --namespace monitoring ./grafana  --set ingress.enabled=true --set ingress.hosts={"grafana.home.pi"}

Kami memeriksa bahwa grafanaport 443 telah ditambahkan ke Ingress dan ada akses melalui HTTPS:

root@pi-control:~# kubectl -n monitoring get ing grafana
NAME      CLASS    HOSTS                     ADDRESS         PORTS     AGE
grafana   <none>   grafana.home.pi           192.168.88.31   80, 443   63m

root@pi-control:~# curl -kI https://grafana.home.pi
HTTP/2 302
server: nginx/1.19.1
date: Tue, 28 Jul 2020 19:01:31 GMT
content-type: text/html; charset=utf-8
cache-control: no-cache
expires: -1
location: /login
pragma: no-cache
set-cookie: redirect_to=%2F; Path=/; HttpOnly; SameSite=Lax
x-frame-options: deny
strict-transport-security: max-age=15724800; includeSubDomains

Untuk mendemonstrasikan Grafana beraksi, Anda dapat mengunduh dan menambahkan dasbor untuk kube-state-metrics . Begini tampilannya: Saya

juga merekomendasikan menambahkan dasbor untuk eksportir node: ini akan menunjukkan secara rinci apa yang terjadi pada "raspberry" (beban CPU, memori, jaringan, penggunaan disk, dll.).

Setelah itu, saya yakin cluster siap menerima dan menjalankan aplikasi!

Catatan perakitan

Setidaknya ada dua opsi untuk membangun aplikasi untuk arsitektur ARM. Pertama, Anda dapat membangun di perangkat ARM. Namun, setelah melihat pembuangan kedua Raspberry Pi saat ini, saya menyadari bahwa mereka juga tidak akan selamat dari perakitan. Oleh karena itu, saya memesan Raspberry Pi 4 baru (lebih kuat dan memiliki memori 4 GB di dalamnya) - saya berencana untuk membangunnya di atasnya.

Opsi kedua adalah membangun image Docker multi-arsitektur pada mesin yang lebih bertenaga. Ada ekstensi buildx buruh pelabuhan untuk itu . Jika aplikasi dalam bahasa yang dikompilasi, maka diperlukan kompilasi silang untuk ARM. Saya tidak akan menjelaskan semua pengaturan untuk jalur ini. ini akan mengarah ke artikel terpisah. Saat mengimplementasikan pendekatan ini, Anda bisa mendapatkan image "universal": Docker yang berjalan di mesin ARM akan otomatis memuat image yang sesuai dengan arsitekturnya.

Kesimpulan

Eksperimen yang dilakukan melebihi semua harapan saya: [setidaknya] "vanilla" Kubernetes dengan basis yang diperlukan terasa nyaman di ARM, dan dengan konfigurasinya, hanya beberapa nuansa yang muncul.

Raspberry Pi 3B + sendiri membuat CPU sibuk, tetapi kartu SD mereka jelas merupakan hambatan. Kolega menyarankan bahwa dalam beberapa versi dimungkinkan untuk boot dari USB, di mana Anda dapat menghubungkan SSD: maka situasinya kemungkinan besar akan menjadi lebih baik.

Berikut ini contoh beban CPU saat menginstal Grafana:

Untuk eksperimen dan "mencoba", menurut saya cluster Kubernetes pada "raspberry" jauh lebih baik dalam menyampaikan sensasi pengoperasian daripada Minikube yang sama, karena semua komponen cluster sudah terpasang dan berfungsi "Secara dewasa."

Di masa depan, ada ide untuk menambahkan seluruh siklus CI / CD ke cluster, yang diterapkan sepenuhnya pada Raspberry Pi. Dan saya juga akan senang jika seseorang membagikan pengalamannya tentang menyiapkan K8 di AWS Gravitons.

PS Ya, "produksi" mungkin lebih dekat dari yang saya kira:

Selesaikan Kubernetes dari awal di Raspberry Pi