Dalam artikel terjemahan baru kami , kami memberikan gambaran singkat tentang distribusi Kubernetes baru. Semoga artikel ini menarik bagi pembaca Habr.
Beberapa hari yang lalu seorang teman memberi tahu saya tentang distribusi Kubernetes baru dari Mirantis yang disebut k0s . Kita semua tahu dan menyukai K8, bukan? Kami juga terpikat oleh K3s , Kubernetes ringan yang dikembangkan oleh Rancher Labs dan diserahkan ke CNCF beberapa waktu lalu. Saatnya menemukan distribusi k0s baru!
Setelah pengenalan singkat tentang k0s, kita akan membuat cluster dari tiga node dengan mengikuti langkah-langkah berikut:
- Mempersiapkan tiga mesin virtual ( Multipass beraksi)
- Menginstal k0s pada masing-masingnya
- Menyiapkan file konfigurasi cluster k0s sederhana
- Inisialisasi cluster
- Mendapatkan akses ke cluster
- Menambahkan node pekerja
- Tambahkan pengguna
Apa itu k0s?
k0s adalah distribusi Kubernetes terbaru. Rilis saat ini adalah 0.8.0. Itu diterbitkan pada Desember 2020, dan komitmen pertama dari keseluruhan proyek terjadi pada Juni 2020.
k0s dikirimkan sebagai file biner tunggal tanpa ketergantungan OS. Jadi, ini didefinisikan sebagai distribusi Kubernetes dengan karakteristik zero-friction / zero-deps / zero-cost (mudah dikonfigurasi / tanpa dependensi / gratis).
Rilis k0s terbaru:
- Memberikan Kubernetes 1.19 tersertifikasi (tersertifikasi Internet Security Center)
- Menggunakan containerd sebagai runtime container default
- Mendukung arsitektur Intel (x86-64) dan ARM (ARM64)
- Menggunakan intra- cluster etcd
- Menggunakan plugin jaringan Calico secara default (dengan demikian mengaktifkan kebijakan jaringan)
- Termasuk Pengontrol Akses Kebijakan Keamanan Pod
- Menggunakan DNS dengan CoreDNS
- Menyediakan metrik cluster melalui Metrics Server
- Mengaktifkan skala otomatis pod horizontal (HPA).
Banyak fitur keren yang akan hadir di rilis mendatang, termasuk:
- Runtime VM kompak (Saya sangat menantikan untuk menguji fitur ini)
- Upgrade Cluster Zero Downtime
- Pencadangan dan pemulihan cluster
Mengesankan, bukan? Selanjutnya, kita akan melihat cara menggunakan k0s untuk menerapkan cluster 3-node.
Mempersiapkan mesin virtual
Pertama, kami akan membuat tiga mesin virtual, yang masing-masing akan menjadi node di cluster kami. Pada artikel ini, saya akan mengambil rute yang cepat dan mudah dan menggunakan alat Multipass yang luar biasa (Saya menyukainya) untuk menyiapkan mesin virtual lokal di MacOS.
Perintah berikut membuat tiga contoh Ubuntu di xhyve. Setiap mesin virtual memiliki 5 GB disk, 2 GB RAM, dan 2 prosesor virtual (vCPU):
for i in 1 2 3; do multipass launch -n node$i -c 2 -m 2G done
Kami kemudian dapat menampilkan daftar mesin virtual untuk memastikan semuanya berfungsi dengan baik:
$ multipass list Name State IPv4 Image node1 Running 192.168.64.11 Ubuntu 20.04 LTS node2 Running 192.168.64.12 Ubuntu 20.04 LTS node3 Running 192.168.64.13 Ubuntu 20.04 LTS
Selanjutnya, kami akan menginstal k0s di masing-masing node ini.
Menginstal rilis k0s terbaru
Rilis terbaru k0s dapat diunduh dari repositori GitHub .
Ini memiliki skrip instalasi yang nyaman:
curl -sSLf get.k0s.sh | sudo sh
Kami menggunakan skrip ini untuk menginstal k0s di semua node kami:
for i in 1 2 3; do multipass exec node$i --bash -c "curl -sSLf get.k0s.sh | sudo sh" done
Skrip di atas menginstal k0s ke / user / bin / k0 . Untuk mendapatkan semua perintah yang tersedia, Anda perlu menjalankan biner tanpa argumen.
Perintah k0s yang tersedia Kami
dapat memeriksa versi saat ini:
$ k0s version v0.8.0
Kami akan menggunakan beberapa perintah di langkah selanjutnya.
Membuat file konfigurasi
Pertama, Anda perlu menentukan file konfigurasi yang berisi informasi yang dibutuhkan k0s untuk membuat cluster. Pada node1, kita dapat menjalankan perintah default-config untuk mendapatkan konfigurasi default penuh. Antara lain, ini memungkinkan kami untuk menentukan:
ubuntu@node1:~$ k0s default-config
apiVersion: k0s.k0sproject.io/v1beta1
kind: Cluster
metadata:
name: k0s
spec:
api:
address: 192.168.64.11
sans:
- 192.168.64.11
- 192.168.64.11
extraArgs: {}
controllerManager:
extraArgs: {}
scheduler:
extraArgs: {}
storage:
type: etcd
kine: null
etcd:
peerAddress: 192.168.64.11
network:
podCIDR: 10.244.0.0/16
serviceCIDR: 10.96.0.0/12
provider: calico
calico:
mode: vxlan
vxlanPort: 4789
vxlanVNI: 4096
mtu: 1450
wireguard: false
podSecurityPolicy:
defaultPolicy: 00-k0s-privileged
workerProfiles: []
extensions: null
images:
konnectivity:
image: us.gcr.io/k8s-artifacts-prod/kas-network-proxy/proxy-agent
version: v0.0.13
metricsserver:
image: gcr.io/k8s-staging-metrics-server/metrics-server
version: v0.3.7
kubeproxy:
image: k8s.gcr.io/kube-proxy
version: v1.19.4
coredns:
image: docker.io/coredns/coredns
version: 1.7.0
calico:
cni:
image: calico/cni
version: v3.16.2
flexvolume:
image: calico/pod2daemon-flexvol
version: v3.16.2
node:
image: calico/node
version: v3.16.2
kubecontrollers:
image: calico/kube-controllers
version: v3.16.2
repository: ""
telemetry:
interval: 10m0s
enabled: true
- Opsi Peluncuran Server API, Manajer Pengontrol, dan Penjadwal
- Penyimpanan yang dapat digunakan untuk menyimpan informasi cluster ( etcd )
- Plugin jaringan dan konfigurasinya ( Calico )
- Versi gambar container dengan komponen manajemen
- Beberapa skema manajemen tambahan untuk diterapkan saat memulai cluster
Kita dapat menyimpan konfigurasi ini ke file dan menyesuaikannya dengan kebutuhan kita. Tetapi untuk artikel ini, kami akan menggunakan konfigurasi yang sangat sederhana dan menyimpannya di /etc/k0s/k0s.yaml . Catatan : Karena kita menginisialisasi cluster pada node1 , node ini akan melayani server API. Alamat IP node ini digunakan di api.address dan api.sans (nama alternatif subjek) di file konfigurasi di atas. Jika kami memiliki node master tambahan dan penyeimbang beban di atasnya, kami juga akan menggunakan api.sans di pengaturan
apiVersion: k0s.k0sproject.io/v1beta1
kind: Cluster
metadata:
name: k0s
spec:
api:
address: 192.168.64.11
sans:
- 192.168.64.11
network:
podCIDR: 10.244.0.0/16
serviceCIDR: 10.96.0.0/12
Alamat IP setiap host dan penyeimbang beban (atau nama domain yang sesuai).
Inisialisasi cluster
Pertama, kami membuat unit systemd pada node1 untuk mengelola k0s.
[Unit] Description="k0s server" After=network-online.target Wants=network-online.target [Service] Type=simple ExecStart=/usr/bin/k0s server -c /etc/k0s/k0s.yaml --enable-worker Restart=always
Perintah utama tercantum di sini di ExecStart ; itu memulai server k0s dengan konfigurasi yang kita simpan ke file kita di langkah sebelumnya. Kami juga menetapkan parameter --enable-worker sehingga node master pertama ini juga berfungsi sebagai pekerja.
Kemudian kami menyalin file ini ke /lib/systemd/system/k0s.service , restart systemd dan mulai layanan yang baru dibuat.
ubuntu@node1:~$ sudo systemctl daemon-reload ubuntu@node1:~$ sudo systemctl start k0s.service
Demi rasa ingin tahu, Anda dapat memeriksa proses yang dimulai oleh server k0s:
ubuntu@node1:~$ sudo ps aux | awk ‘{print $11}’ | grep k0s /usr/bin/k0s /var/lib/k0s/bin/etcd /var/lib/k0s/bin/konnectivity-server /var/lib/k0s/bin/kube-controller-manager /var/lib/k0s/bin/kube-scheduler /var/lib/k0s/bin/kube-apiserver /var/lib/k0s/bin/containerd /var/lib/k0s/bin/kubelet
Dari output di atas, kita dapat melihat bahwa semua komponen utama sedang berjalan ( kube-apiserver , kube-controller-manager , kube-scheduler , dll.), Serta komponen yang umum untuk node master dan pekerja ( containerd , kubelet ). k0s bertanggung jawab untuk mengelola semua komponen ini.
Sekarang kami memiliki cluster 1 node. Pada langkah selanjutnya, kita akan melihat cara mengaksesnya.
Mendapatkan akses ke cluster
Pertama, kita perlu mendapatkan file kubeconfig yang dihasilkan selama pembuatan cluster; itu dibuat pada node1 di /var/lib/k0s/pki/admin.conf . File ini harus digunakan untuk mengkonfigurasi kubectl di mesin lokal.
Pertama, kita mendapatkan kubeconfig cluster dari node1 :
# Get kubeconfig file $ multipass exec node1 cat /var/lib/k0s/pki/admin.conf > k0s.cfg
Selanjutnya, kami mengganti alamat IP internal dengan alamat IP eksternal node1 :
# Replace IP address $ NODE1_IP=$(multipass info node1 | grep IP | awk '{print $2}') sed -i '' "s/localhost/$NODE1_IP/" k0s.cfg
Kemudian kami mengkonfigurasi klien kubectl lokal kami untuk berkomunikasi dengan server API k0s:
export KUBECONFIG=$PWD/k0s.cfg
Tentunya salah satu perintah pertama yang kita jalankan ketika kita memasuki cluster baru adalah yang menampilkan daftar semua node yang tersedia - mari kita coba:
$ kubectl get no NAME STATUS ROLES AGE VERSION node1 Ready <none> 78s v1.19.4
Tidak ada yang mengejutkan di sini. Bagaimanapun, node1 bukan hanya yang utama, tetapi juga node yang berfungsi dari cluster pertama kita berkat tanda --enable-worker , yang kita tentukan di perintah start. Tanpa tanda ini, node1 hanya akan berfungsi dan tidak akan muncul dalam daftar node di sini.
Menambahkan node pekerja
Untuk menambahkan node2 dan node3 ke cluster , pertama-tama kita perlu membuat token koneksi dari node1 (ini adalah langkah yang cukup umum karena digunakan di cluster Docker Swarm dan Kubernetes yang dibuat dengan kubeadm).
$ TOKEN=$(k0s token create --role=worker)
Perintah di atas menghasilkan token yang panjang (sangat panjang). Dengan menggunakannya, kita dapat menggabungkan node2 dan node3 ke cluster :
ubuntu@node2:~$ k0s worker $TOKEN ubuntu@node3:~$ k0s worker $TOKEN
Catatan: Dalam cluster nyata, kami akan menggunakan systemd (atau supervisor lain) untuk mengelola proses k0s untuk node pekerja, seperti yang kami lakukan untuk node master.
Cluster tiga node kami aktif dan berjalan, karena kami dapat memverifikasi dengan menampilkan daftar node dan mendaftar node lagi:
$ kubectl get no NAME STATUS ROLES AGE VERSION node1 Ready <none> 30m v1.19.4 node2 Ready <none> 35s v1.19.4 node3 Ready <none> 32s v1.19.4
Kami juga dapat memeriksa pod yang berjalan di semua namespace:
Daftar pod yang berjalan di cluster di semua namespace
Ada beberapa hal yang perlu diperhatikan di sini:
- Seperti biasa, kita melihat pod kube -proxy , pod plugin jaringan (berdasarkan Calico), serta pod CoreDNS.
- api-server, scheduler controller-manager , , .
K0s versi 0.8.0 berisi subperintah pengguna . Ini memungkinkan Anda membuat kubeconfig untuk pengguna / grup tambahan. Misalnya, perintah berikut membuat file kubeconfig bernama demo untuk pengguna baru , yang berada di dalam grup imajiner yang disebut development .
Catatan: Di Kubernetes, pengguna dan grup dikelola oleh administrator di luar cluster, yang berarti tidak ada sumber daya pengguna-bukan-grup di K8s.
$ sudo k0s user create demo --groups development > demo.kubeconfig
Untuk pemahaman yang lebih baik, kami akan mengekstrak sertifikat klien dari file kubeconfig ini dan mendekodekannya dari representasi base64:
$ cat demo.kubeconfig | grep client-certificate-data | awk '{print $2}' | base64 --decode > demo.crt
Kemudian kami menggunakan perintah openssl untuk mendapatkan konten sertifikat:
ubuntu@node1:~$ openssl x509 -in demo.crt -noout -text
Certificate:
Data:
Version: 3 (0x2)
Serial Number:
71:8b:a4:4d:be:76:70:8a:...:07:60:67:c1:2d:51:94
Signature Algorithm: sha256WithRSAEncryption
Issuer: CN = kubernetes-ca
Validity
Not Before: Dec 2 13:50:00 2020 GMT
Not After : Dec 2 13:50:00 2021 GMT
Subject: O = development, CN = demo
Subject Public Key Info:
Public Key Algorithm: rsaEncryption
RSA Public-Key: (2048 bit)
Modulus:
00:be:87:dd:15:46:91:98:eb:b8:38:34:77:a4:99:
da:4b:d6:ca:09:92:f3:29:28:2d:db:7a:0b:9f:91:
65:f3:11:bb:6c:88:b1:8f:46:6e:38:71:97:b7:b5:
9b:8d:32:86:1f:0b:f8:4e:57:4f:1c:5f:9f:c5:ee:
40:23:80:99:a1:77:30:a3:46:c1:5b:3e:1c:fa:5c:
- Properti penerbitnya adalah kubernetes-ca , yang merupakan CA untuk cluster k0s kita.
- Subjeknya adalah O = pengembangan, CN = demo ; bagian ini penting karena di sinilah nama dan grup pengguna masuk. Karena sertifikat ditandatangani oleh cluster CA, plugin di api-server dapat mengautentikasi pengguna / grup dengan nama umum (CN) dan organisasi (O) dalam subjek sertifikat.
Pertama, kami menginstruksikan kubectl untuk menggunakan konteks yang ditentukan dalam file kubeconfig baru ini :
$ export KUBECONFIG=$PWD/demo.kubeconfig
Kemudian sekali lagi kami menampilkan daftar node dan menghitung node cluster:
$ kubectl get no Error from server (Forbidden): nodes is forbidden: User “demo” cannot list resource “nodes” in API group “” at the cluster scope
Pesan kesalahan ini diharapkan. Meskipun
api-server
pengguna diidentifikasi (sertifikat yang dikirim dengan permintaan pengguna ditandatangani oleh cluster CA), dia tidak diizinkan untuk melakukan tindakan apa pun di cluster.
Izin tambahan dapat dengan mudah ditambahkan dengan membuat
Role/ClusterRole
dan menetapkannya ke pengguna dengan
RoleBinding/ClusterRoleBinding
, tetapi saya membiarkan tugas ini sebagai latihan untuk pembaca.
Kesimpulan
k0s pasti layak dipertimbangkan. Pendekatan ini, ketika satu file biner mengelola semua proses, sangat menarik.
Artikel ini hanya memberikan gambaran singkat tentang k0s, tetapi saya pasti akan melacak perkembangannya dan mencurahkan artikel mendatang untuk distribusi Kubernetes yang baru dan menjanjikan ini. Beberapa fitur masa depan tampak sangat menjanjikan, dan saya berharap untuk mengujinya.