Bagian 2/3 di sini
Bagian 3/3 di sini
Halo semuanya! Pada artikel ini saya ingin merampingkan informasi dan berbagi pengalaman membuat dan menggunakan cluster internal Kubernetes.
Selama beberapa tahun terakhir, teknologi orkestrasi wadah ini telah mengambil langkah besar ke depan dan telah menjadi semacam standar perusahaan bagi ribuan perusahaan. Beberapa menggunakannya dalam produksi, yang lain hanya mengujinya pada proyek, tetapi gairah di sekitarnya, tidak peduli bagaimana Anda mengatakannya, bersinar dengan serius. Jika Anda belum pernah menggunakannya sebelumnya, saatnya untuk mulai berkencan.
0. Pendahuluan
Kubernetes adalah teknologi orkestrasi scalable yang dapat dimulai dengan instalasi pada satu node dan mencapai ukuran cluster HA besar berdasarkan beberapa ratus node di dalamnya. Sebagian besar penyedia cloud populer menyediakan berbagai jenis implementasi Kubernet - ambil dan gunakan. Tetapi situasinya berbeda, dan ada perusahaan yang tidak menggunakan cloud, dan mereka ingin mendapatkan semua keuntungan dari teknologi orkestrasi modern. Dan inilah instalasi Kubernetes pada logam telanjang.
1. Pendahuluan
Dalam contoh ini, kita akan membuat kluster Kubernetes HA dengan topologi untuk beberapa master, dengan kluster eksternal dll sebagai lapisan dasar dan penyeimbang beban MetalLB di dalamnya. Pada semua node yang berfungsi, kami akan menggunakan GlusterFS sebagai penyimpanan cluster terdistribusi internal yang sederhana. Kami juga akan mencoba untuk menyebarkan beberapa proyek pengujian di dalamnya menggunakan registri Docker pribadi kami.
Secara umum, ada beberapa cara untuk membuat kluster Kubernetes HA: jalur yang sulit dan mendalam yang dijelaskan dalam dokumen kubernet-cara-keras yang populer , atau cara yang lebih sederhana menggunakan utilitas kubeadm .
Kubeadm adalah alat yang dibuat oleh komunitas Kubernetes khusus untuk menyederhanakan pemasangan Kubernetes dan mempermudah proses. Sebelumnya, Kubeadm direkomendasikan hanya untuk membuat kelompok uji kecil dengan satu node master, untuk memulai. Tetapi selama setahun terakhir, banyak yang telah diperbaiki, dan sekarang kita dapat menggunakannya untuk membuat cluster HA dengan beberapa node master. Menurut berita komunitas Kubernetes, di masa depan, Kubeadm akan direkomendasikan sebagai alat untuk menginstal Kubernetes.
Dokumentasi Kubeadm menawarkan dua cara dasar untuk mengimplementasikan sebuah cluster, dengan topologi stack dan eksternal dll. Saya akan memilih jalur kedua dengan node eksternal dll karena toleransi kesalahan dari cluster HA.
Berikut adalah diagram dari dokumentasi Kubeadm yang menjelaskan jalur ini:
Saya akan mengubahnya sedikit. Pertama, saya akan menggunakan sepasang server HAProxy sebagai load balancer dengan paket Heartbeat, yang akan membagikan alamat IP virtual. Heartbeat dan HAProxy menggunakan sejumlah kecil sumber daya sistem, jadi saya akan menempatkan mereka pada sepasang node etcd untuk sedikit mengurangi jumlah server untuk cluster kami.
Untuk skema kluster Kubernetes ini, diperlukan delapan node. Tiga server untuk cluster eksternal dll (layanan LB juga akan menggunakan beberapa dari mereka), dua untuk node dari bidang kontrol (master node) dan tiga untuk node yang berfungsi. Ini bisa berupa bare metal atau server VM. Dalam hal ini, itu tidak masalah. Anda dapat dengan mudah mengubah skema dengan menambahkan lebih banyak node master dan menempatkan HAProxy dengan Heartbeat pada node yang berbeda, jika ada banyak server gratis. Meskipun opsi saya untuk implementasi pertama dari cluster HA sudah cukup untuk mata.
Jika Anda mau, tambahkan server kecil dengan utilitas kubectl yang diinstal untuk mengelola cluster ini atau gunakan desktop Linux Anda sendiri untuk ini.
Diagram untuk contoh ini akan terlihat seperti ini:
2. Persyaratan
Anda memerlukan dua node master Kubernetes dengan persyaratan sistem minimum yang disarankan: 2 CPU dan 2 GB RAM sesuai dengan dokumentasi kubeadm . Untuk node yang berfungsi, saya sarankan menggunakan server yang lebih kuat, karena kami akan menjalankan semua layanan aplikasi kami pada mereka. Dan untuk Etcd + LB, kita juga dapat mengambil server dengan dua CPU dan setidaknya 2 GB RAM.
Pilih jaringan publik atau jaringan pribadi untuk klaster ini; Alamat IP tidak masalah; Sangat penting bahwa semua server dapat diakses satu sama lain dan, tentu saja, untuk Anda. Nantinya, di dalam kluster Kubernetes, kami akan menyiapkan jaringan overlay.
Persyaratan minimum untuk contoh ini adalah:
- 2 server dengan 2 prosesor dan 2 GB RAM untuk master node
- 3 server dengan 4 prosesor dan 4-8 GB RAM untuk node yang berfungsi
- 3 server dengan 2 prosesor dan 2 GB RAM untuk Etcd dan HAProxy
- 192.168.0.0/24 - subnet.
192.168.0.1 - alamat IP virtual HAProxy, 192.168.0.2 - 4 alamat IP utama dari node Etcd dan HAProxy, 192.168.0.5 - 6 alamat IP utama dari simpul master Kubernetes, 192.168.0.7 - 9 alamat IP utama dari simpul kerja Kubernetes .
Database Debian 9 diinstal pada semua server.
Juga ingat bahwa persyaratan sistem tergantung pada seberapa besar dan kuatnya klaster. Untuk informasi lebih lanjut, lihat dokumentasi Kubernetes.
3. Konfigurasikan HAProxy dan Detak Jantung.
Kami memiliki lebih dari satu simpul master Kubernetes, dan oleh karena itu Anda perlu mengonfigurasi penyeimbang beban HAProxy di depannya - untuk mendistribusikan lalu lintas. Ini akan menjadi sepasang server HAProxy dengan satu alamat IP virtual bersama. Toleransi kesalahan disediakan dengan paket Heartbeat. Untuk penyebaran, kami akan menggunakan dua server etcd pertama.
Instal dan konfigurasikan HAProxy dengan Heartbeat pada server etcd pertama dan kedua (192.168.0.2–3 dalam contoh ini):
etcd1# apt-get update && apt-get upgrade && apt-get install -y haproxy etcd2# apt-get update && apt-get upgrade && apt-get install -y haproxy
Simpan konfigurasi asli dan buat yang baru:
etcd1# mv /etc/haproxy/haproxy.cfg{,.back} etcd1# vi /etc/haproxy/haproxy.cfg etcd2# mv /etc/haproxy/haproxy.cfg{,.back} etcd2# vi /etc/haproxy/haproxy.cfg
Tambahkan opsi konfigurasi ini untuk kedua HAProxy:
global user haproxy group haproxy defaults mode http log global retries 2 timeout connect 3000ms timeout server 5000ms timeout client 5000ms frontend kubernetes bind 192.168.0.1:6443 option tcplog mode tcp default_backend kubernetes-master-nodes backend kubernetes-master-nodes mode tcp balance roundrobin option tcp-check server k8s-master-0 192.168.0.5:6443 check fall 3 rise 2 server k8s-master-1 192.168.0.6:6443 check fall 3 rise 2
Seperti yang Anda lihat, kedua layanan HAProxy berbagi alamat IP - 192.168.0.1. Alamat IP virtual ini akan berpindah di antara server, jadi kami akan sedikit lihai dan mengaktifkan parameter net.ipv4.ip_nonlocal_bind untuk memungkinkan pengikatan layanan sistem ke alamat IP non-lokal.
Tambahkan fitur ini ke file /etc/sysctl.conf :
etcd1# vi /etc/sysctl.conf net.ipv4.ip_nonlocal_bind=1 etcd2# vi /etc/sysctl.conf net.ipv4.ip_nonlocal_bind=1
Jalankan di kedua server:
sysctl -p
Jalankan juga HAProxy di kedua server:
etcd1# systemctl start haproxy etcd2# systemctl start haproxy
Pastikan HAProxy berjalan dan mendengarkan pada alamat IP virtual di kedua server:
etcd1# netstat -ntlp tcp 0 0 192.168.0.1:6443 0.0.0.0:* LISTEN 2833/haproxy etcd2# netstat -ntlp tcp 0 0 192.168.0.1:6443 0.0.0.0:* LISTEN 2833/haproxy
Tudung! Sekarang instal Heartbeat dan konfigurasikan IP virtual ini.
etcd1# apt-get -y install heartbeat && systemctl enable heartbeat etcd2# apt-get -y install heartbeat && systemctl enable heartbeat
Saatnya membuat beberapa file konfigurasi untuknya: untuk server pertama dan kedua mereka pada dasarnya akan sama.
Pertama buat file /etc/ha.d/authkeys , dalam file ini Heartbeat menyimpan data untuk otentikasi bersama. File harus sama di kedua server:
# echo -n securepass | md5sum bb77d0d3b3f239fa5db73bdf27b8d29a etcd1# vi /etc/ha.d/authkeys auth 1 1 md5 bb77d0d3b3f239fa5db73bdf27b8d29a etcd2# vi /etc/ha.d/authkeys auth 1 1 md5 bb77d0d3b3f239fa5db73bdf27b8d29a
File ini hanya dapat diakses untuk melakukan root:
etcd1# chmod 600 /etc/ha.d/authkeys etcd2# chmod 600 /etc/ha.d/authkeys
Sekarang buat file konfigurasi utama untuk Detak Jantung di kedua server: untuk setiap server akan sedikit berbeda.
Buat /etc/ha.d/ha.cf :
dlld1
etcd1# vi /etc/ha.d/ha.cf # keepalive: how many seconds between heartbeats # keepalive 2 # # deadtime: seconds-to-declare-host-dead # deadtime 10 # # What UDP port to use for udp or ppp-udp communication? # udpport 694 bcast ens18 mcast ens18 225.0.0.1 694 1 0 ucast ens18 192.168.0.3 # What interfaces to heartbeat over? udp ens18 # # Facility to use for syslog()/logger (alternative to log/debugfile) # logfacility local0 # # Tell what machines are in the cluster # node nodename ... -- must match uname -n node etcd1_hostname node etcd2_hostname
dlld2
etcd2# vi /etc/ha.d/ha.cf # keepalive: how many seconds between heartbeats # keepalive 2 # # deadtime: seconds-to-declare-host-dead # deadtime 10 # # What UDP port to use for udp or ppp-udp communication? # udpport 694 bcast ens18 mcast ens18 225.0.0.1 694 1 0 ucast ens18 192.168.0.2 # What interfaces to heartbeat over? udp ens18 # # Facility to use for syslog()/logger (alternative to vlog/debugfile) # logfacility local0 # # Tell what machines are in the cluster # node nodename ... -- must match uname -n node etcd1_hostname node etcd2_hostname
Dapatkan parameter "simpul" untuk konfigurasi ini dengan menjalankan uname -n di kedua server Etcd. Juga gunakan nama kartu jaringan Anda sebagai ganti EN18.
Terakhir, Anda perlu membuat file /etc/ha.d/haresources di server ini. Untuk kedua server, file harus sama. Dalam file ini, kami menetapkan alamat IP umum kami dan menentukan simpul mana yang merupakan master default:
etcd1# vi /etc/ha.d/haresources etcd1_hostname 192.168.0.1 etcd2# vi /etc/ha.d/haresources etcd1_hostname 192.168.0.1
Ketika semuanya sudah siap, mulai layanan Detak Jantung di kedua server dan verifikasi bahwa kami menerima ini IP virtual yang dinyatakan pada node etcd1:
etcd1# systemctl restart heartbeat etcd2# systemctl restart heartbeat etcd1# ip a ens18: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000 link/ether xx:xx:xx:xx:xx:xx brd ff:ff:ff:ff:ff:ff inet 192.168.0.2/24 brd 192.168.0.255 scope global ens18 valid_lft forever preferred_lft forever inet 192.168.0.1/24 brd 192.168.0.255 scope global secondary
Anda dapat memverifikasi bahwa HAProxy berfungsi dengan baik dengan menjalankan nc di 192.168.0.1 6443. Anda harus kehabisan waktu karena Kubernetes API belum mendengarkan di sisi server. Tetapi ini berarti bahwa HAProxy dan Detak Jantung dikonfigurasikan dengan benar.
# nc -v 192.168.0.1 6443 Connection to 93.158.95.90 6443 port [tcp/*] succeeded!
4. Persiapan node untuk Kubernetes
Langkah selanjutnya adalah mempersiapkan semua node Kubernetes. Anda perlu menginstal Docker dengan beberapa paket tambahan, menambahkan repositori Kubernetes dan menginstal paket kubelet , kubeadm , kubectl darinya. Pengaturan ini sama untuk semua node Kubernetes (master, pekerja, dll.)
Keuntungan utama Kubeadm adalah tidak perlu banyak perangkat lunak tambahan. Instal kubeadm di semua host - dan gunakan; setidaknya buat sertifikat CA.
Instal Docker di semua node:
Update the apt package index # apt-get update Install packages to allow apt to use a repository over HTTPS # apt-get -y install \ apt-transport-https \ ca-certificates \ curl \ gnupg2 \ software-properties-common Add Docker's official GPG key # curl -fsSL https://download.docker.com/linux/debian/gpg | sudo apt-key add - Add docker apt repository # apt-add-repository \ "deb [arch=amd64] https://download.docker.com/linux/debian \ $(lsb_release -cs) \ stable" Install docker-ce. # apt-get update && apt-get -y install docker-ce Check docker version # docker -v Docker version 18.09.0, build 4d60db4
Setelah itu, instal paket Kubernetes di semua node:
kubeadm : perintah untuk memuat cluster.kubelet : komponen yang berjalan di semua komputer di cluster dan melakukan tindakan seperti meluncurkan perapian dan wadah.kubectl : util command line untuk berkomunikasi dengan cluster.- kubectl — sesuka hati; Saya sering menginstalnya di semua node untuk menjalankan beberapa perintah Kubernetes untuk debugging.
# curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add - Add the Google repository # cat <<EOF >/etc/apt/sources.list.d/kubernetes.list deb https://apt.kubernetes.io/ kubernetes-xenial main EOF Update and install packages # apt-get update && apt-get install -y kubelet kubeadm kubectl Hold back packages # apt-mark hold kubelet kubeadm kubectl Check kubeadm version # kubeadm version kubeadm version: &version.Info{Major:"1", Minor:"13", GitVersion:"v1.13.1", GitCommit:"eec55b9dsfdfgdfgfgdfgdfgdf365bdd920", GitTreeState:"clean", BuildDate:"2018-12-13T10:36:44Z", GoVersion:"go1.11.2", Compiler:"gc", Platform:"linux/amd64"}
Setelah menginstal kubeadm dan paket lainnya, jangan lupa untuk menonaktifkan swap.
# swapoff -a # sed -i '/ swap / s/^/#/' /etc/fstab
Ulangi instalasi pada node yang tersisa. Paket perangkat lunak adalah sama untuk semua node di cluster, dan hanya konfigurasi berikut yang akan menentukan peran yang akan mereka terima nanti.
5. Konfigurasikan HA Etcd Cluster
Jadi, setelah menyelesaikan persiapan, kita akan mengkonfigurasi cluster Kubernetes. Bata pertama adalah HA Etcd cluster, yang juga dikonfigurasi menggunakan alat kubeadm.
Sebelum kita mulai, pastikan bahwa semua node etcd berkomunikasi melalui port 2379 dan 2380. Selain itu, Anda perlu mengkonfigurasi akses ssh di antara mereka untuk menggunakan scp .
Mari kita mulai dengan node etcd pertama, dan kemudian salin semua sertifikat dan file konfigurasi yang diperlukan ke server lain.
Pada semua node etcd , Anda perlu menambahkan file konfigurasi systemd baru untuk unit kubelet dengan prioritas yang lebih tinggi:
etcd-nodes# cat << EOF > /etc/systemd/system/kubelet.service.d/20-etcd-service-manager.conf [Service] ExecStart= ExecStart=/usr/bin/kubelet --address=127.0.0.1 --pod-manifest-path=/etc/kubernetes/manifests --allow-privileged=true Restart=always EOF etcd-nodes# systemctl daemon-reload etcd-nodes# systemctl restart kubelet
Kemudian kita akan membahas ssh ke node etcd pertama - kita akan menggunakannya untuk menghasilkan semua konfigurasi kubeadm yang diperlukan untuk setiap node etcd , dan kemudian menyalinnya.
# Export all our etcd nodes IP's as variables etcd1# export HOST0=192.168.0.2 etcd1# export HOST1=192.168.0.3 etcd1# export HOST2=192.168.0.4 # Create temp directories to store files for all nodes etcd1# mkdir -p /tmp/${HOST0}/ /tmp/${HOST1}/ /tmp/${HOST2}/ etcd1# ETCDHOSTS=(${HOST0} ${HOST1} ${HOST2}) etcd1# NAMES=("infra0" "infra1" "infra2") etcd1# for i in "${!ETCDHOSTS[@]}"; do HOST=${ETCDHOSTS[$i]} NAME=${NAMES[$i]} cat << EOF > /tmp/${HOST}/kubeadmcfg.yaml apiVersion: "kubeadm.k8s.io/v1beta1" kind: ClusterConfiguration etcd: local: serverCertSANs: - "${HOST}" peerCertSANs: - "${HOST}" extraArgs: initial-cluster: ${NAMES[0]}=https://${ETCDHOSTS[0]}:2380,${NAMES[1]}=https://${ETCDHOSTS[1]}:2380,${NAMES[2]}=https://${ETCDHOSTS[2]}:2380 initial-cluster-state: new name: ${NAME} listen-peer-urls: https://${HOST}:2380 listen-client-urls: https://${HOST}:2379 advertise-client-urls: https://${HOST}:2379 initial-advertise-peer-urls: https://${HOST}:2380 EOF done
Sekarang buat otoritas sertifikat utama menggunakan kubeadm
etcd1# kubeadm init phase certs etcd-ca
Perintah ini akan membuat dua file ca.crt & ca.key di direktori / etc / kubernetes / pki / etcd / .
etcd1# ls /etc/kubernetes/pki/etcd/ ca.crt ca.key
Sekarang kita akan menghasilkan sertifikat untuk semua node etcd :
### Create certificates for the etcd3 node etcd1# kubeadm init phase certs etcd-server --config=/tmp/${HOST2}/kubeadmcfg.yaml etcd1# kubeadm init phase certs etcd-peer --config=/tmp/${HOST2}/kubeadmcfg.yaml etcd1# kubeadm init phase certs etcd-healthcheck-client --config=/tmp/${HOST2}/kubeadmcfg.yaml etcd1# kubeadm init phase certs apiserver-etcd-client --config=/tmp/${HOST2}/kubeadmcfg.yaml etcd1# cp -R /etc/kubernetes/pki /tmp/${HOST2}/ ### cleanup non-reusable certificates etcd1# find /etc/kubernetes/pki -not -name ca.crt -not -name ca.key -type f -delete ### Create certificates for the etcd2 node etcd1# kubeadm init phase certs etcd-server --config=/tmp/${HOST1}/kubeadmcfg.yaml etcd1# kubeadm init phase certs etcd-peer --config=/tmp/${HOST1}/kubeadmcfg.yaml etcd1# kubeadm init phase certs etcd-healthcheck-client --config=/tmp/${HOST1}/kubeadmcfg.yaml etcd1# kubeadm init phase certs apiserver-etcd-client --config=/tmp/${HOST1}/kubeadmcfg.yaml etcd1# cp -R /etc/kubernetes/pki /tmp/${HOST1}/ ### cleanup non-reusable certificates again etcd1# find /etc/kubernetes/pki -not -name ca.crt -not -name ca.key -type f -delete ### Create certificates for the this local node etcd1# kubeadm init phase certs etcd-server --config=/tmp/${HOST0}/kubeadmcfg.yaml etcd1 #kubeadm init phase certs etcd-peer --config=/tmp/${HOST0}/kubeadmcfg.yaml etcd1# kubeadm init phase certs etcd-healthcheck-client --config=/tmp/${HOST0}/kubeadmcfg.yaml etcd1# kubeadm init phase certs apiserver-etcd-client --config=/tmp/${HOST0}/kubeadmcfg.yaml # No need to move the certs because they are for this node # clean up certs that should not be copied off this host etcd1# find /tmp/${HOST2} -name ca.key -type f -delete etcd1# find /tmp/${HOST1} -name ca.key -type f -delete
Kemudian salin sertifikat dan konfigurasi kubeadm ke node etcd2 dan etcd3 .
Pertama-tama buat sepasang kunci ssh pada etcd1 dan tambahkan bagian publik ke node etcd2 dan 3 . Dalam contoh ini, semua perintah dijalankan atas nama pengguna yang memiliki semua hak dalam sistem.
etcd1# scp -r /tmp/${HOST1}/* ${HOST1}: etcd1# scp -r /tmp/${HOST2}/* ${HOST2}: ### login to the etcd2 or run this command remotely by ssh etcd2# cd /root etcd2# mv pki /etc/kubernetes/ ### login to the etcd3 or run this command remotely by ssh etcd3# cd /root etcd3# mv pki /etc/kubernetes/
Sebelum memulai cluster etcd, pastikan file ada di semua node:
Daftar file yang diperlukan di etcd1 :
/tmp/192.168.0.2 └── kubeadmcfg.yaml --- /etc/kubernetes/pki ├── apiserver-etcd-client.crt ├── apiserver-etcd-client.key └── etcd ├── ca.crt ├── ca.key ├── healthcheck-client.crt ├── healthcheck-client.key ├── peer.crt ├── peer.key ├── server.crt └── server.key
Untuk node etcd2, ini adalah:
/root └── kubeadmcfg.yaml --- /etc/kubernetes/pki ├── apiserver-etcd-client.crt ├── apiserver-etcd-client.key └── etcd ├── ca.crt ├── healthcheck-client.crt ├── healthcheck-client.key ├── peer.crt ├── peer.key ├── server.crt └── server.key
Dan simpul terakhir adalah etcd3 :
/root └── kubeadmcfg.yaml --- /etc/kubernetes/pki ├── apiserver-etcd-client.crt ├── apiserver-etcd-client.key └── etcd ├── ca.crt ├── healthcheck-client.crt ├── healthcheck-client.key ├── peer.crt ├── peer.key ├── server.crt └── server.key
Ketika semua sertifikat dan konfigurasi sudah ada, kami membuat manifes. Pada setiap node, jalankan perintah kubeadm - untuk menghasilkan manifes statis untuk cluster etcd :
etcd1# kubeadm init phase etcd local --config=/tmp/192.168.0.2/kubeadmcfg.yaml etcd1# kubeadm init phase etcd local --config=/root/kubeadmcfg.yaml etcd1# kubeadm init phase etcd local --config=/root/kubeadmcfg.yaml
Sekarang dlld cluster - dalam teori - dikonfigurasi dan sehat. Verifikasi dengan menjalankan perintah berikut pada node etcd1:
etcd1# docker run --rm -it \ --net host \ -v /etc/kubernetes:/etc/kubernetes quay.io/coreos/etcd:v3.2.24 etcdctl \ --cert-file /etc/kubernetes/pki/etcd/peer.crt \ --key-file /etc/kubernetes/pki/etcd/peer.key \ --ca-file /etc/kubernetes/pki/etcd/ca.crt \ --endpoints https://192.168.0.2:2379 cluster-health ### status output member 37245675bd09ddf3 is healthy: got healthy result from https://192.168.0.3:2379 member 532d748291f0be51 is healthy: got healthy result from https://192.168.0.4:2379 member 59c53f494c20e8eb is healthy: got healthy result from https://192.168.0.2:2379 cluster is healthy
Cluster etcd telah meningkat, jadi lanjutkan.
6. Mengkonfigurasi node master dan work
Konfigurasikan node master cluster kami - salin file-file ini dari node etcd pertama ke node master pertama:
etcd1# scp /etc/kubernetes/pki/etcd/ca.crt 192.168.0.5: etcd1# scp /etc/kubernetes/pki/apiserver-etcd-client.crt 192.168.0.5: etcd1# scp /etc/kubernetes/pki/apiserver-etcd-client.key 192.168.0.5:
Kemudian pergi ssh ke master node master1 dan buat file kubeadm-config.yaml dengan konten berikut:
master1# cd /root && vi kubeadm-config.yaml apiVersion: kubeadm.k8s.io/v1beta1 kind: ClusterConfiguration kubernetesVersion: stable apiServer: certSANs: - "192.168.0.1" controlPlaneEndpoint: "192.168.0.1:6443" etcd: external: endpoints: - https://192.168.0.2:2379 - https://192.168.0.3:2379 - https://192.168.0.4:2379 caFile: /etc/kubernetes/pki/etcd/ca.crt certFile: /etc/kubernetes/pki/apiserver-etcd-client.crt keyFile: /etc/kubernetes/pki/apiserver-etcd-client.key
Pindahkan sertifikat dan kunci yang sebelumnya disalin ke direktori yang sesuai pada node master1, seperti pada deskripsi pengaturan.
master1# mkdir -p /etc/kubernetes/pki/etcd/ master1# cp /root/ca.crt /etc/kubernetes/pki/etcd/ master1# cp /root/apiserver-etcd-client.crt /etc/kubernetes/pki/ master1# cp /root/apiserver-etcd-client.key /etc/kubernetes/pki/
Untuk membuat master node pertama, lakukan:
master1# kubeadm init --config kubeadm-config.yaml
Jika semua langkah sebelumnya selesai dengan benar, Anda akan melihat yang berikut:
You can now join any number of machines by running the following on each node as root: kubeadm join 192.168.0.1:6443 --token aasuvd.kw8m18m5fy2ot387 --discovery-token-ca-cert-hash sha256:dcbaeed8d1478291add0294553b6b90b453780e546d06162c71d515b494177a6
Salin output inisialisasi kubeadm ini ke file teks apa pun, kami akan menggunakan token ini di masa mendatang ketika kami melampirkan master kedua dan node yang berfungsi ke cluster kami.
Saya telah mengatakan bahwa kluster Kubernetes akan menggunakan beberapa jenis jaringan overlay untuk perapian dan layanan lainnya, jadi pada titik ini Anda perlu menginstal beberapa jenis plugin CNI. Saya merekomendasikan plugin Weave CNI . Pengalaman menunjukkan bahwa ini lebih bermanfaat dan tidak terlalu bermasalah, tetapi Anda dapat memilih yang lain, misalnya, Calico.
Menginstal plugin jaringan Weave pada node master pertama:
master1# kubectl --kubeconfig /etc/kubernetes/admin.conf apply -f "https://cloud.weave.works/k8s/net?k8s-version=$(kubectl version | base64 | tr -d '\n')" The connection to the server localhost:8080 was refused - did you specify the right host or port? serviceaccount/weave-net created clusterrole.rbac.authorization.k8s.io/weave-net created clusterrolebinding.rbac.authorization.k8s.io/weave-net created role.rbac.authorization.k8s.io/weave-net created rolebinding.rbac.authorization.k8s.io/weave-net created daemonset.extensions/weave-net created
Tunggu sebentar, lalu masukkan perintah berikut untuk memverifikasi bahwa komponen perapian mulai:
master1# kubectl --kubeconfig /etc/kubernetes/admin.conf get pod -n kube-system -w NAME READY STATUS RESTARTS AGE coredns-86c58d9df4-d7qfw 1/1 Running 0 6m25s coredns-86c58d9df4-xj98p 1/1 Running 0 6m25s kube-apiserver-master1 1/1 Running 0 5m22s kube-controller-manager-master1 1/1 Running 0 5m41s kube-proxy-8ncqw 1/1 Running 0 6m25s kube-scheduler-master1 1/1 Running 0 5m25s weave-net-lvwrp 2/2 Running 0 78s
- Disarankan untuk melampirkan node baru dari bidang kontrol hanya setelah inisialisasi node pertama.
Untuk memeriksa status cluster, lakukan:
master1# kubectl --kubeconfig /etc/kubernetes/admin.conf get nodes NAME STATUS ROLES AGE VERSION master1 Ready master 11m v1.13.1
Hebat! Node master pertama naik. Sekarang sudah siap, dan kita akan selesai membuat cluster Kubernetes - kita akan menambahkan master node kedua dan node yang berfungsi.
Untuk menambahkan simpul master kedua, buat kunci ssh pada master1 dan tambahkan bagian publik ke master2 . Lakukan login uji coba, dan kemudian salin beberapa file dari master node pertama ke yang kedua:
master1# scp /etc/kubernetes/pki/ca.crt 192.168.0.6: master1# scp /etc/kubernetes/pki/ca.key 192.168.0.6: master1# scp /etc/kubernetes/pki/sa.key 192.168.0.6: master1# scp /etc/kubernetes/pki/sa.pub 192.168.0.6: master1# scp /etc/kubernetes/pki/front-proxy-ca.crt @192.168.0.6: master1# scp /etc/kubernetes/pki/front-proxy-ca.key @192.168.0.6: master1# scp /etc/kubernetes/pki/apiserver-etcd-client.crt @192.168.0.6: master1# scp /etc/kubernetes/pki/apiserver-etcd-client.key @192.168.0.6: master1# scp /etc/kubernetes/pki/etcd/ca.crt 192.168.0.6:etcd-ca.crt master1# scp /etc/kubernetes/admin.conf 192.168.0.6: ### Check that files was copied well master2# ls /root admin.conf ca.crt ca.key etcd-ca.crt front-proxy-ca.crt front-proxy-ca.key sa.key sa.pub
Pada node master kedua, pindahkan sertifikat dan kunci yang sebelumnya disalin ke direktori yang sesuai:
master2# mkdir -p /etc/kubernetes/pki/etcd mv /root/ca.crt /etc/kubernetes/pki/ mv /root/ca.key /etc/kubernetes/pki/ mv /root/sa.pub /etc/kubernetes/pki/ mv /root/sa.key /etc/kubernetes/pki/ mv /root/apiserver-etcd-client.crt /etc/kubernetes/pki/ mv /root/apiserver-etcd-client.key /etc/kubernetes/pki/ mv /root/front-proxy-ca.crt /etc/kubernetes/pki/ mv /root/front-proxy-ca.key /etc/kubernetes/pki/ mv /root/etcd-ca.crt /etc/kubernetes/pki/etcd/ca.crt mv /root/admin.conf /etc/kubernetes/admin.conf
Hubungkan node master kedua ke cluster. Untuk melakukan ini, Anda memerlukan output dari perintah koneksi, yang sebelumnya dikirimkan kepada kami oleh kubeadm init pada node pertama.
Jalankan master node master2 :
master2# kubeadm join 192.168.0.1:6443 --token aasuvd.kw8m18m5fy2ot387 --discovery-token-ca-cert-hash sha256:dcbaeed8d1478291add0294553b6b90b453780e546d06162c71d515b494177a6 --experimental-control-plane
- Anda perlu menambahkan
--experimental-control-plane . Ini mengotomatiskan lampiran data master ke sebuah cluster. Tanpa tanda ini, simpul kerja yang biasa hanya akan ditambahkan.
Tunggu sedikit hingga node bergabung dengan cluster, dan periksa status baru cluster:
master1# kubectl --kubeconfig /etc/kubernetes/admin.conf get nodes NAME STATUS ROLES AGE VERSION master1 Ready master 32m v1.13.1 master2 Ready master 46s v1.13.1
Pastikan juga semua pod dari semua node master dimulai dengan normal:
master1# kubectl — kubeconfig /etc/kubernetes/admin.conf get pod -n kube-system -w NAME READY STATUS RESTARTS AGE coredns-86c58d9df4-d7qfw 1/1 Running 0 46m coredns-86c58d9df4-xj98p 1/1 Running 0 46m kube-apiserver-master1 1/1 Running 0 45m kube-apiserver-master2 1/1 Running 0 15m kube-controller-manager-master1 1/1 Running 0 45m kube-controller-manager-master2 1/1 Running 0 15m kube-proxy-8ncqw 1/1 Running 0 46m kube-proxy-px5dt 1/1 Running 0 15m kube-scheduler-master1 1/1 Running 0 45m kube-scheduler-master2 1/1 Running 0 15m weave-net-ksvxz 2/2 Running 1 15m weave-net-lvwrp 2/2 Running 0 41m
Hebat! Kami hampir selesai dengan konfigurasi cluster Kubernetes. Dan hal terakhir yang harus dilakukan adalah menambahkan tiga node kerja yang kami siapkan sebelumnya.
Masukkan node yang berfungsi dan jalankan perintah join kubeadm tanpa --experimental-control-plane .
worker1-3# kubeadm join 192.168.0.1:6443 --token aasuvd.kw8m18m5fy2ot387 --discovery-token-ca-cert-hash sha256:dcbaeed8d1478291add0294553b6b90b453780e546d06162c71d515b494177a6
Periksa status gugus lagi:
master1# kubectl --kubeconfig /etc/kubernetes/admin.conf get nodes NAME STATUS ROLES AGE VERSION master1 Ready master 1h30m v1.13.1 master2 Ready master 1h59m v1.13.1 worker1 Ready <none> 1h8m v1.13.1 worker2 Ready <none> 1h8m v1.13.1 worker3 Ready <none> 1h7m v1.13.1
Seperti yang Anda lihat, kami memiliki kluster Kubernetes HA yang sepenuhnya dikonfigurasi dengan dua master dan tiga node yang berfungsi. Itu dibangun berdasarkan HA etcd cluster dengan penyeimbang beban gagal-aman di depan master node. Kedengarannya bagus untukku.
7. Mengkonfigurasi manajemen cluster jarak jauh
Tindakan lain yang masih harus dipertimbangkan dalam bagian pertama artikel ini adalah mengatur utilitas kubectl jarak jauh untuk mengelola cluster. Sebelumnya, kami menjalankan semua perintah dari master node master1 , tetapi ini hanya cocok untuk pertama kalinya - saat mengkonfigurasi cluster. Akan lebih baik untuk mengkonfigurasi node kontrol eksternal. Anda dapat menggunakan laptop atau server lain untuk ini.
Masuk ke server ini dan jalankan:
Add the Google repository key control# curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add - Add the Google repository control# cat <<EOF >/etc/apt/sources.list.d/kubernetes.list deb https://apt.kubernetes.io/ kubernetes-xenial main EOF Update and install kubectl control# apt-get update && apt-get install -y kubectl In your user home dir create control# mkdir ~/.kube Take the Kubernetes admin.conf from the master1 node control# scp 192.168.0.5:/etc/kubernetes/admin.conf ~/.kube/config Check that we can send commands to our cluster control# kubectl get nodes NAME STATUS ROLES AGE VERSION master1 Ready master 6h58m v1.13.1 master2 Ready master 6h27m v1.13.1 worker1 Ready <none> 5h36m v1.13.1 worker2 Ready <none> 5h36m v1.13.1 worker3 Ready <none> 5h36m v1.13.1
Ok, sekarang mari kita jalankan tes di bawah di cluster kami dan periksa cara kerjanya.
control# kubectl create deployment nginx --image=nginx deployment.apps/nginx created control# kubectl get pods NAME READY STATUS RESTARTS AGE nginx-5c7588df-6pvgr 1/1 Running 0 52s
Selamat! Anda baru saja menggunakan Kubernet. Dan itu berarti cluster HA baru Anda siap. Bahkan, proses pengaturan cluster Kubernetes menggunakan kubeadm cukup sederhana dan cepat.
Pada bagian selanjutnya dari artikel ini, kami akan menambahkan penyimpanan internal dengan menyiapkan GlusterFS pada semua node yang bekerja, menyiapkan penyeimbang beban internal untuk cluster Kubernetes kami, dan juga menjalankan tes stres tertentu, memutuskan beberapa node, dan memeriksa stabilitas cluster.
Kata penutup
Ya, dengan mengerjakan contoh ini, Anda akan menemukan sejumlah masalah. Tidak perlu khawatir: untuk membatalkan perubahan dan mengembalikan node ke keadaan semula, jalankan saja kubeadm reset - perubahan yang kubeadm buat sebelumnya akan diatur ulang, dan Anda dapat mengonfigurasi lagi. Juga, jangan lupa untuk memeriksa status kontainer Docker pada node cluster - pastikan semuanya mulai dan bekerja tanpa kesalahan. Untuk informasi lebih lanjut tentang kontainer yang rusak, gunakan perintah buruh pelabuhan log containerid .
Itu saja untuk hari ini. Semoga beruntung