Edit This Page

Membangun Klaster dengan Ketersediaan Tinggi menggunakan kubeadm

Laman ini menjelaskan dua pendekatan yang berbeda untuk membuat klaster Kubernetes dengan ketersediaan tinggi menggunakan kubeadm:

  • Dengan Node control plane yang bertumpuk (stacked). Pendekatan ini membutuhkan sumber daya infrastruktur yang lebih sedikit. Anggota-anggota etcd dan Node control plane diletakkan pada tempat yang sama (co-located).
  • Dengan klaster etcd eksternal. Pendekatan ini membutuhkan lebih banyak sumber daya infrastruktur. Node control plane dan anggota etcd berada pada tempat yang berbeda.

Sebelum memulai, kamu harus memikirkan dengan matang pendekatan mana yang paling sesuai untuk kebutuhan aplikasi dan environment-mu. Topik perbandingan berikut menguraikan kelebihan dan kekurangan dari masing-masing pendekatan.

Jika kamu menghadapi masalah dalam pembuatan klaster dengan ketersediaan tinggi, silakan berikan umpan balik pada pelacak isu kubeadm.

Lihat juga dokumentasi pembaruan.

Perhatian: Laman ini tidak menunjukkan cara untuk menjalankan klastermu pada penyedia layanan cloud. Pada environment cloud, kedua pendekatan yang didokumentasikan di sini tidak akan bekerja untuk objek Service dengan tipe LoadBalancer maupun PersistentVolume dinamis.

Sebelum mulai

Untuk kedua metode kamu membutuhkan infrastruktur seperti berikut:

  • Tiga mesin yang memenuhi kebutuhan minimum kubeadm untuk Node control plane
  • Tiga mesin yang memenuhi kebutuhan minimum kubeadm untuk Node worker
  • Konektivitas internet pada seluruh mesin di dalam klaster (baik jaringan publik maupun jaringan pribadi)
  • Hak akses sudo pada seluruh mesin
  • Akses SSH dari satu perangkat ke seluruh Node pada sistem
  • Perkakas kubeadm dan kubelet diinstal pada seluruh mesin. Perkakas kubectl bersifat opsional.

Untuk klaster etcd eksternal saja, kamu juga membutuhkan:

  • Tiga mesin tambahan untuk anggota-anggota etcd

Langkah pertama untuk kedua metode

Membuat load balancer untuk kube-apiserver

Catatan: Akan ada banyak konfigurasi untuk load balancer. Contoh berikut ini hanyalah salah satu opsi. Kebutuhan klastermu mungkin membutuhkan konfigurasi berbeda.
  1. Buat sebuah load balancer kube-apiserver dengan sebuah nama yang yang akan mengubah ke dalam bentuk DNS.

    • Pada environment cloud kamu harus meletakkan Node control plane di belakang load balancer yang meneruskan TCP. Load balancer ini mendistribusikan trafik ke seluruh Node control plane pada daftar tujuan. Health check untuk apiserver adalah pengujian TCP pada porta yang didengarkan oleh kube-apiserver (nilai semula :6443).

    • Tidak direkomendasikan untuk menggunakan alamat IP secara langsung pada environment cloud.

    • Load balancer harus dapat berkomunikasi dengan seluruh Node control plane pada porta yang digunakan apiserver. Load balancer tersebut juga harus mengizinkan trafik masuk pada porta yang didengarkannya.

    • Pastikan alamat load balancer sesuai dengan alamat ControlPlaneEndpoint pada kubeadm.

    • Baca panduan Opsi untuk Software Load Balancing untuk detail lebih lanjut.

  2. Tambahkan Node control plane pertama pada load balancer dan lakukan pengujian koneksi:

    nc -v LOAD_BALANCER_IP PORT
    
    • Kegalatan koneksi yang ditolak memang diantisipasi karena apiserver belum berjalan. Namun jika mendapat timeout, berarti load balancer tidak dapat berkomunikasi dengan Node control plane. Jika terjadi timeout, lakukan pengaturan ulang pada load balancer agar dapat berkomunikasi dengan Node control plane.
  3. Tambahkan Node control plane lainnya pada grup tujuan load balancer.

Node control plane dan etcd bertumpuk (stacked)

Langkah-langkah untuk Node control plane pertama

  1. Inisialisasi control plane:

    sudo kubeadm init --control-plane-endpoint "LOAD_BALANCER_DNS:LOAD_BALANCER_PORT" --upload-certs
    
    • Kamu bisa menggunakan opsi --kubernetes-version untuk mengatur versi Kubernetes yang akan digunakan. Direkomendasikan untuk menggunakan versi kubeadm, kubelet, kubectl, dan Kubernetes yang sama.

    • Opsi --control-plane-endpoint harus diatur menuju alamat atau DNS dan porta dari load balancer.

    • Opsi --upload-certs digunakan untuk mengunggah sertifikat-sertifikat yang harus dibagikan ke seluruh Node control plane pada klaster. Jika sebaliknya, kamu memilih untuk menyalin sertifikat ke seluruh Node control plane sendiri atau menggunakan perkakas automasi, silakan hapus opsi ini dan merujuk ke bagian Distribusi sertifikat manual di bawah.

    Catatan: Opsi --config dan --certificate-key pada kubeadm init tidak dapat digunakan secara bersamaan, maka dari itu jika kamu ingin menggunakan konfigurasi kubeadm kamu harus menambahkan field certificateKey pada lokasi pengaturan yang sesuai (berada di bawah InitConfiguration dan JoinConfiguration: controlPlane).
    Catatan: Beberapa plugin jaringan CNI membutuhkan pengaturan tambahan, seperti menentukan CIDR IP untuk Pod, meski beberapa lainnya tidak. Lihat dokumentasi jaringan CNI. Untuk menambahkan CIDR Pod, tambahkan opsi --pod-network-cidr, atau jika kamu menggunakan berkas konfigurasi kubeadm pasang field podSubnet di bawah objek networking dari ClusterConfiguration.
    • Keluaran yang dihasilkan terlihat seperti berikut ini:

      ...
      You can now join any number of control-plane node by running the following command on each as a root:
          kubeadm join 192.168.0.200:6443 --token 9vr73a.a8uxyaju799qwdjv --discovery-token-ca-cert-hash sha256:7c2e69131a36ae2a042a339b33381c6d0d43887e2de83720eff5359e26aec866 --control-plane --certificate-key f8902e114ef118304e561c3ecd4d0b543adc226b7a07f675f56564185ffe0c07
            
      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 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.0.200:6443 --token 9vr73a.a8uxyaju799qwdjv --discovery-token-ca-cert-hash sha256:7c2e69131a36ae2a042a339b33381c6d0d43887e2de83720eff5359e26aec866
      
    • Salin keluaran ini pada sebuah berkas teks. Kamu akan membutuhkannya nanti untuk menggabungkan Node control plane dan worker ke klaster.

    • Ketika opsi --upload-certs digunakan dengan kubeadm init, sertifikat dari control plane utama akan dienkripsi dan diunggah ke Secret kubeadm-certs.

    • Untuk mengunggah ulang sertifikat dan membuat kunci dekripsi baru, gunakan perintah berikut pada Node control plane yang sudah tergabung pada klaster:

      sudo kubeadm init phase upload-certs --upload-certs
      
    • Kamu juga dapat menentukan --certificate-key custom pada saat init yang nanti dapat digunakan pada saat join. Untuk membuat kunci tersebut kamu dapat menggunakan perintah berikut:

      kubeadm alpha certs certificate-key
      
    Catatan: Secret kubeadm-certs dan kunci dekripsi akan kadaluarsa setelah dua jam.
    Perhatian: Seperti yang tertera pada keluaran perintah, kunci sertifikat memberikan akses ke data klaster yang bersifat sensitif, jaga kerahasiaannya!
  2. Pasang plugin CNI pilihanmu: Ikuti petunjuk berikut untuk menginstal penyedia CNI. Pastikan konfigurasinya sesuai dengan CIDR Pod yang ditentukan pada berkas konfigurasi kubeadm jika diterapkan.

    Pada contoh berikut kami menggunakan Weave Net:

    kubectl apply -f "https://cloud.weave.works/k8s/net?k8s-version=$(kubectl version | base64 | tr -d '\n')"
    
  3. Tulis perintah berikut dan saksikan Pod komponen-komponen control plane mulai dinyalakan:

    kubectl get pod -n kube-system -w
    

Langkah-langkah selanjutnya untuk Node control plane

Catatan: Sejak kubeadm versi 1.15 kamu dapat menggabungkan beberapa Node control plane secara bersamaan. Pada versi sebelumnya, kamu harus menggabungkan Node control plane baru secara berurutan, setelah Node pertama selesai diinisialisasi.

Untuk setiap Node control plane kamu harus:

  1. Mengeksekusi perintah untuk bergabung yang sebelumnya diberikan pada keluaran kubeadm init pada Node pertama. Perintah tersebut terlihat seperti ini:

    sudo kubeadm join 192.168.0.200:6443 --token 9vr73a.a8uxyaju799qwdjv --discovery-token-ca-cert-hash sha256:7c2e69131a36ae2a042a339b33381c6d0d43887e2de83720eff5359e26aec866 --control-plane --certificate-key f8902e114ef118304e561c3ecd4d0b543adc226b7a07f675f56564185ffe0c07
    
    • Opsi --control-plane menunjukkan kubeadm join untuk membuat control plane baru.
    • Opsi --certificate-key ... akan membuat sertifikat control plane diunduh dari Secret kubeadm-certs pada klaster dan didekripsi menggunakan kunci yang diberikan.

Node etcd eksternal

Membangun sebuah klaster dengan Node etcd eksternal memiliki prosedur yang mirip dengan etcd bertumpuk dengan pengecualian yaitu kamu harus setup etcd terlebih dulu, dan kamu harus memberikan informasi etcd pada berkas konfigurasi kubeadm.

Memasang klaster etcd

  1. Ikuti petunjuk berikut untuk membangun klaster etcd.

  2. Lakukan pengaturan SSH seperti yang dijelaskan di sini.

  3. Salin berkas-berkas berikut dari Node etcd manapun pada klaster ke Node control plane pertama:

    export CONTROL_PLANE="ubuntu@10.0.0.7"
    scp /etc/kubernetes/pki/etcd/ca.crt "${CONTROL_PLANE}":
    scp /etc/kubernetes/pki/apiserver-etcd-client.crt "${CONTROL_PLANE}":
    scp /etc/kubernetes/pki/apiserver-etcd-client.key "${CONTROL_PLANE}":
    
    • Ganti nilai CONTROL_PLANE dengan user@host dari mesin control plane pertama.

Mengatur Node control plane pertama

  1. Buat sebuah berkas bernama kubeadm-config.yaml dengan konten sebagai berikut:

    apiVersion: kubeadm.k8s.io/v1beta2
    kind: ClusterConfiguration
    kubernetesVersion: stable
    controlPlaneEndpoint: "LOAD_BALANCER_DNS:LOAD_BALANCER_PORT"
    etcd:
        external:
            endpoints:
            - https://ETCD_0_IP:2379
            - https://ETCD_1_IP:2379
            - https://ETCD_2_IP:2379
            caFile: /etc/kubernetes/pki/etcd/ca.crt
            certFile: /etc/kubernetes/pki/apiserver-etcd-client.crt
            keyFile: /etc/kubernetes/pki/apiserver-etcd-client.key
    
Catatan: Perbedaan antara etcd bertumpuk dan etcd eksternal yaitu etcd eksternal membutuhkan sebuah berkas konfigurasi dengan endpoint etcd di bawah objek externaluntuk etcd. Pada kasus ini topologi etcd bertumpuk dikelola secara otomatis.
  • Ganti variabel-variabel berikut pada templat konfigurasi dengan nilai yang sesuai untuk klastermu:
- `LOAD_BALANCER_DNS`
- `LOAD_BALANCER_PORT`
- `ETCD_0_IP`
- `ETCD_1_IP`
- `ETCD_2_IP`

Langkah-langkah berikut sama dengan pengaturan pada etcd bertumpuk:

  1. Jalankan sudo kubeadm init --config kubeadm-config.yaml --upload-certs pada Node ini.

  2. Tulis perintah untuk bergabung yang didapat dari keluaran ke dalam sebuah berkas teks untuk digunakan nanti.

  3. Pasang plugin CNI pilihanmu. Contoh berikut ini untuk Weave Net:

    kubectl apply -f "https://cloud.weave.works/k8s/net?k8s-version=$(kubectl version | base64 | tr -d '\n')"
    

Langkah selanjutnya untuk Node control plane lainnya

Langkah-langkah selanjutnya sama untuk pengaturan etcd bertumpuk:

  • Pastikan Node control plane pertama sudah diinisialisasi dengan sempurna.
  • Gabungkan setiap Node control plane dengan perintah untuk bergabung yang kamu simpan dalam berkas teks. Direkomendasikan untuk menggabungkan Node control plane satu persatu.
  • Jangan lupakan bahwa kunci dekripsi dari --certificate-key akan kadaluarsa setelah dua jam, pada pengaturan semula.

Tugas-tugas umum setelah menyiapkan control plane

Menginstal worker

Node worker bisa digabungkan ke klaster menggunakan perintah yang kamu simpan sebelumnya dari keluaran perintah kubeadm init:

sudo kubeadm join 192.168.0.200:6443 --token 9vr73a.a8uxyaju799qwdjv --discovery-token-ca-cert-hash sha256:7c2e69131a36ae2a042a339b33381c6d0d43887e2de83720eff5359e26aec866

Distribusi sertifikat manual

Jika kamu memilih untuk tidak menggunakan kubeadm init dengan opsi --upload-certs berarti kamu harus menyalin sertifikat dari Node control plane utama secara manual ke Node control plane yang akan bergabung.

Ada beberapa cara untuk melakukan hal ini. Pada contoh berikut ini kami menggunakan ssh dan scp:

SSH dibutuhkan jika kamu ingin mengendalikan seluruh Node dari satu mesin.

  1. Nyalakan ssh-agent pada perangkat utamamu yang memiliki akses ke seluruh Node pada sistem:

    eval $(ssh-agent)
    
  2. Tambahkan identitas SSH milikmu ke dalam sesi:

    ssh-add ~/.ssh/path_to_private_key
    
  3. Lakukan SSH secara bergantian ke setiap Node untuk memastikan koneksi bekerja dengan baik.

    • Ketika kamu melakukan SSH ke Node, pastikan untuk menambahkan opsi -A:

      ssh -A 10.0.0.7
      
    • Jika kamu menggunakan sudo pada Node, pastikan kamu menyimpan environment yang ada sehingga penerusan SSH dapat bekerja dengan baik:

      sudo -E -s
      
  4. Setelah mengatur SSH pada seluruh Node kamu harus menjalankan skrip berikut pada Node control plane pertama setelah menjalankan kubeadm init. Skrip ini akan menyalin sertifikat dari Node control plane pertama ke Node control plane lainnya:

    Pada contoh berikut, ganti CONTROL_PLANE_IPS dengan alamat IP dari Node control plane lainnya.

    USER=ubuntu # dapat disesuaikan
    CONTROL_PLANE_IPS="10.0.0.7 10.0.0.8"
    for host in ${CONTROL_PLANE_IPS}; do
        scp /etc/kubernetes/pki/ca.crt "${USER}"@$host:
        scp /etc/kubernetes/pki/ca.key "${USER}"@$host:
        scp /etc/kubernetes/pki/sa.key "${USER}"@$host:
        scp /etc/kubernetes/pki/sa.pub "${USER}"@$host:
        scp /etc/kubernetes/pki/front-proxy-ca.crt "${USER}"@$host:
        scp /etc/kubernetes/pki/front-proxy-ca.key "${USER}"@$host:
        scp /etc/kubernetes/pki/etcd/ca.crt "${USER}"@$host:etcd-ca.crt
        # Kutip baris berikut jika kamu menggunakan etcd eksternal
        scp /etc/kubernetes/pki/etcd/ca.key "${USER}"@$host:etcd-ca.key
    done
    
    Perhatian: Salinlah hanya sertifikat yang berada pada daftar di atas saja. Perkakas kubeadm akan mengambil alih pembuatan sertifikat lainnya dengan SANs yang dibutuhkan untuk Node control plane yang akan bergabung. Jika kamu menyalin seluruh sertifikat tanpa sengaja, pembuatan Node tambahan dapat gagal akibat tidak adanya SANs yang dibutuhkan.
  5. Lalu, pada setiap Node control plane yang bergabung kamu harus menjalankan skrip berikut sebelum menjalankan kubeadm join. Skrip ini akan memindahkan sertifikat yang telah disalin sebelumnya dari direktori home ke /etc/kubernetes/pki:

    USER=ubuntu # dapat disesuaikan
    mkdir -p /etc/kubernetes/pki/etcd
    mv /home/${USER}/ca.crt /etc/kubernetes/pki/
    mv /home/${USER}/ca.key /etc/kubernetes/pki/
    mv /home/${USER}/sa.pub /etc/kubernetes/pki/
    mv /home/${USER}/sa.key /etc/kubernetes/pki/
    mv /home/${USER}/front-proxy-ca.crt /etc/kubernetes/pki/
    mv /home/${USER}/front-proxy-ca.key /etc/kubernetes/pki/
    mv /home/${USER}/etcd-ca.crt /etc/kubernetes/pki/etcd/ca.crt
    # Kutip baris berikut jika kamu menggunakan etcd eksternal
    mv /home/${USER}/etcd-ca.key /etc/kubernetes/pki/etcd/ca.key