Ubuntu’ya Kubernetes Nasıl Kurulur?

Docker konteynerlerinin birden fazla sunucuya manuel olarak dağıtılması, oldukça zaman alıcı olabilir ve bu görevle görevlendirilen herhangi bir sistem yöneticisinin programını tekelinde tutabilir. Modern BT sektöründe bulutların, mikro hizmetlerin ve konteynerlerin popülaritesi artmaya devam ediyor ve bu nedenle Kubernetes gibi çözümler geliştirildi.

Kubernetes, konteynerlerin dağıtılmış ortamlarda dağıtılmasını kolaylaştırmak ve konteynerli uygulamalar için yüksek kullanılabilirlik sağlamak için bir küme oluşturmanıza olanak tanıyan açık kaynaklı bir konteyner yönetimi ve orkestrasyon çözümüdür. Bu blog yazısının amacı, Docker konteynerlerindeki uygulamaları çalıştırmak için Kubernetes’in Ubuntu’ya nasıl kurulacağını keşfetmektir.

Ubuntu’ya Kubernetes Kurulumu İçin Gereksinimler ve Sistem Yapılandırması

Kubernetes kümesi master node ve worker node’lardan oluşur. Donanım yapılandırması ihtiyaçlarınıza ve Docker konteynerlerinde çalıştırmayı planladığınız uygulamalara bağlıdır. Kubernetes’i Ubuntu’ya yüklemek için minimum donanım gereksinimleri şunlardır:

• En az 2 çekirdekli x86/x64 CPU
• 2 GB RAM veya daha fazlası
• internet erişimi

Ubuntu’ya Kubernetes kurulumu için açılması gereken portlar:

Varsayılan olarak iptables güvenlik duvarı Ubuntu’da yüklüdür, ancak “kutudan çıktığı gibi” herhangi bir engelleme kuralı yoktur. Dolayısıyla Kubernetes’i denemek için Ubuntu kuruyorsanız güvenlik duvarı kurallarını düzenlemenize gerek yoktur. Kube-proxy önce iptables zincirlerini yerleştirir ve ardından iki iptables kuralı ekler. Bu kurallar INPUT zincirinin en üstüne eklenen KUBE-EXTERNAL-SERVICES ve KUBE-FIREWALL kurallarıdır.

Kubernetes’in Ubuntu’ya kurulumu hem fiziksel hem de sanal makinelerde yapılabilir. Genel öneri 64 bit Ubuntu Linux’un en son sürümünü kullanmaktır. Bugünkü blog yazısında Kubernetes’in VMware VM’lerinde çalışan Ubuntu 18.04 LTS’ye kurulumu açıklanıyor. Açıklanan ilk Kubernetes dağıtım türü master node’dur ve Kubernetes kümesi için iki tane worker node kullanılır. Söz konusu örnekte kullanılan makinelerin koşullu düğüm sayılarını, düğüm rollerini, ana bilgisayar adlarını ve IP adreslerini görüntülemek için aşağıdaki tabloya bakın.

VMware vSphere kullanıyorsanız ESXi hostlar üzerinde çalışan VM’leri kullanabileceğiniz gibi Linux veya Windows yüklü kişisel bilgisayarınızda kurulu VMware Workstation üzerinde VM’leri çalıştırabilirsiniz. Bugünkü örneğimizde VMware Workstation üzerinde çalışan VM’leri kullanıyoruz. VM’ler internet erişimi ile NAT ağını kullanır ve VirtualBox’u VMware’e tercih ederseniz kullanabilirsiniz.

Ana makinenin IP adresi: 10.10.10.53

NAT ağı (VMNet8) için sanal ağ geçidinin IP adresi: 192.168.101.2

Tüm Ubuntu makinelerinde aynı Linux kullanıcısı mevcut: kubernetes-user

VM yapılandırması: 2CPU, 4GB RAM, 20 GB sanal disk

VMware Workstation’da Edit > Virtual Network Editor menüsüne giderek VMnet8’in IP adreslerini değiştirebilirsiniz.

Daha iyi anlaşılması için, bugünkü örnekte tüm bileşenler Ansible gibi otomasyon araçları olmadan Linux’a manuel olarak kurulacaktır.

Ubuntu VM’i oluşturma

Docker-nakivo21 adında yeni bir VM oluşturun.

İlk makineye Ubuntu 64-bit’i kurun ve ana makine adını ve kullanıcı adını ayarlayın.

VM adı: docker-nakivo21

Kullanıcı adı: kubernetes-user

Kurulu işletim sistemine ilk kez giriş yaptıktan sonra VMware Tools’u yükleyin. Fiziksel makineler kullanıyorsanız VMware Tools kullanmanıza gerek yoktur ve bu adımı atlayabilirsiniz.

Not: Başlangıçtaki $ karakteri, bir komutun normal kullanıcı (bu durumda kubernetes kullanıcısı) olarak çalıştırıldığı anlamına gelir. Dize # karakteriyle başlıyorsa, komutun root olarak çalıştırılması gerekir. Sudo (yedek kullanıcı do veya süper kullanıcı do) komutu, komutları root dahil başka bir kullanıcı olarak çalıştırmanıza olanak tanır. Konsolda kök ayrıcalıklarını almak için sudo -i yazabilirsiniz. Kök modundan çıkmak için Ctrl+D tuşlarına basın.

VMware Tools’u, VMware hipervizörüyle sağlanan ISO görüntüsünden veya Linux depolarından (aşağıda açıklanmıştır) yükleyebilirsiniz.

VM’yi yeniden başlatın.

$ init 6

Kubernetes Kurulumundan Önce Ubuntu Makinenizi Yapılandırın

Ubuntu makinelerine Kubernetes kurulmadan önce bazı hazırlıkların yapılması gerekmektedir. Her şeyden önce, herhangi bir normal sunucu için statik IP adresini ve ana bilgisayar adını yapılandırmanız gerekir.

Statik IP adresini ayarlayın

Diğer küme türlerinde olduğu gibi, düğümlerde statik IP adreslerinin kullanılması önemle tavsiye edilir.

IP adresini ayarlamadan önce Linux ağ oluşturma araçlarını yükleyin.

$ sudo apt-get install net-tools

Ubuntu VM’nizin geçerli IP adresini kontrol etmek için ifconfig yazın.

IP adresinin DHCP aracılığıyla otomatik olarak alındığını görebilirsiniz. Ağ arayüzünün adını unutmayın. Mevcut örnekte bu ad ens33’tür. Fiziksel makineler için ilk Ethernet ağ arayüzünün adı genellikle eth0’dır.

Yapılandırma dosyalarını düzenlemek için bir metin düzenleyiciye ihtiyacınız vardır. Vim’i metin düzenleyici olarak yükleyin.

$ sudo apt-get install vim

En son Ubuntu sürümlerinde ağ yapılandırması yaml dosyasında ayarlanır. Ağ yapılandırması yaml dosyasını vim’de açın.

$ sudo vim /etc/netplan/01-network-manager-all.yaml

Yapılandırma dosyasının varsayılan görünümü şöyledir:

Bu ağ yapılandırma dosyasını aşağıda gösterildiği gibi düzenleyin:

network:

version: 2

renderer: networkd

ethernets:

ens33:

dhcp4: no

addresses: [192.168.101.21/24]

gateway4: 192.168.101.2

nameservers:

addresses: [192.168.101.2,8.8.8.8]

Değişiklikleri Kaydet ve Çık.

:wq

$ sudo netplan try

Yeni yapılandırmayı kabul etmek için ENTER tuşuna basın.

Ağ yapılandırmanızın değiştirilip değiştirilmediğini kontrol edin ve örneğin nakivo.com’a ping atmayı deneyin.

$ ifconfig

$ ping nakivo.com

sunucu adını yapılandırın

Mevcut sunucu adınızı kontrol edin.

$ hostnamectl

Hatırlayacağınız gibi ilk VM’nin sunucu adı olan docker-nakivo21, kurulum sırasında zaten yapılandırılmıştı. Sunucu adını değiştirmek için aşağıdakileri yapın (klonlamadan sonra ikinci ve üçüncü VM’leri yapılandırmak için bu gerekli olacaktır. Bu iki VM’nin, worker node olarak yapılandırılması amaçlanmıştır):

Örneğin, ilk VM’de ana bilgisayar adını docker-nakivo21 olarak değiştirmeniz gerekiyorsa şunu çalıştırın:

$ sudo hostnamectl set-hostname docker-nakivo21

Yeni bir ana bilgisayar adının uygulandığını kontrol edin.

$ less /etc/hostname

Host dosyasını düzenleyin.

$ sudo vim /etc/hosts

Ana bilgisayarın dosyasının içeriği şu şekilde görünmelidir:

127.0.0.1 localhost

127.0.1.1 docker-nakivo21

Makineyi yeniden başlatın.

$ init 6

Takas dosyasını devre dışı bırakın

Takas dosyası (takas bölümü) kullanmak Kubernetes tarafından desteklenmez ve Kubernetes’i Ubuntu’ya başarıyla yüklemek için takas özelliğinin devre dışı bırakılması gerekir.

Kubelet’in yüksek CPU kullanımını önlemek için takas dosyasını devre dışı bırakın.

$ sudo swapoff -a

/etc/fstab dosyasını düzenleyin ve # karakterini kullanarak dizeye yorum yapın.

$ sudo vim /etc/fstab

#/swapfile none swap sw 0 0

Aynısını sed ile tek bir komutla yapabilirsiniz:

$ sudo sed -i ‘/ swap / s/^\(.*\)$/#\1/g’ /etc/fstab

Sysctl.conf’ta takası devre dışı bırakın

$ sudo echo “vm.swappiness=0” | sudo tee –append /etc/sysctl.conf

Burada 0 takas yüzdesidir. Bu durumda takas yalnızca RAM’iniz yetersizse kullanılabilir (varsayılan olarak takas, RAM’in %60’ından fazlası dolu olduğunda kullanılır).

Yapılandırma değişikliklerini yeniden başlatmadan uygulayın.

$ sudo sysctl -p

Not: Takas bölümü devre dışı bırakılmazsa Kubernetes çalıştıran Ubuntu Linux’un kswapd0 işlemi, makinenizde büyük miktarda CPU kaynağı tüketerek uygulamaların yanıt vermemesine ve sistemin kilitlenmesine neden olabilir. Bu, işletim sisteminin belleği tükendiğinde ve eski bellek sayfaları bir Linux çekirdek sistemi işlemi tarafından değiştirilmek üzere taşındığında meydana gelir. Garip sebeplerden dolayı bazen işler ters gider ve tüm CPU kaynaklarını tüketen, hiç bitmeyen bir döngü oluşur. Aşağıdaki ekran görüntüsünde Ubuntu üzerinde Kubernetes kurulduğunda kswapd0 işleminin yüksek CPU tüketimini görüyorsunuz. Yük ortalama değeri aşırı yüksek.

Kswapd0 hala CPU’nuza aşırı yükleniyorsa, tüm bellek nakitlerini geçersiz kılmak ve kswapd0’ı durdurmak (root olarak çalıştırmak) için aşağıdaki komutu çalıştırın.

# echo 1 > /proc/sys/vm/drop_caches

VM’yi kapatın.

$ init 0

Kısmen yapılandırılmış bu sanal makine (docker-nakivo21), master node olarak kullanılmaya hazır. Worker node olarak kullanılacak iki makine daha oluşturun. Fiziksel makineler kullanıyorsanız önceki adımları manuel olarak tekrarlayın (veya birden fazla Linux makinesini aynı anda SSH aracılığıyla yapılandırmak için Ansible gibi otomasyon araçlarını kullanın). Mevcut örnekte VM’ler kullanıldığından, Ubuntu makinelerine Kubernetes kurulumu için ortam hazırlanırken zaman kazanmak amacıyla klonlanabilirler.

VM’i klonlayın

İlk VM’nizi klonlayın. VMware ESXi kullanıyorsanız klonlama özelliğini kullanabilirsiniz. VMware Workstation kullanıyorsanız iki yöntemi ( klonlama aracı ve manuel olarak) kullanarak da VM’leri klonlayabilirsiniz. Bağlantılı bir klon oluşturmak için VM > Manage > Clone‘a tıklayabilirsiniz. İlk VM’nin tam bir klonunu oluşturalım ve VM dosyalarını manuel olarak kopyalayalım. Bu durumda dosyalar docker-nakivo21 dizininden docker-nakivo31’e kopyalanır. VM dosyalarını kopyalamadan önce dizinlerin manuel olarak oluşturulması gerekir.

VM adı ve sanal disk dosyasının yolu değiştirildiği için VMX dosyasını düzenleyin.

displayName = “docker-nakivo31”

scsi0:0.fileName = “C:\Virtual\KUBERNETES\docker-nakivo31\docker-nakivo31.vmdk”

nvram = “docker-nakivo31.nvram”

İlk worker node olarak kullanılacak VM artık oluşturulmuştur. Kubernetes kümesinin ikinci worker node’u hazırlamak için ilk VM’yi bir kez daha klonlayın.

Daha önce yaptığınız gibi, üçüncü VM için VMX dosyasını düzenleyin.

displayName = “docker-nakivo32”

scsi0:0.fileName = “C:\Virtual\KUBERNETES\docker-nakivo31\docker-nakivo32.vmdk”

nvram = “docker-nakivo32.nvram”

VM klonlarını VMware Workstation’da açın (File> Open ve VM’nin VMX dosyasını seçin) veya VM’nin VMX dosyasına çift tıklayın. Üç sanal makineyi açın (tek kaynak VM’niz ve iki VM klonunuz). İstendiğinde Kopyaladım’a tıklayın.

Not: Sanal makineler kullanıyorsanız, VM’ler klonlandıktan sonra her VM klonundaki IP adresini ve ana bilgisayar adını düzenleyin. Fiziksel makineler kullanıyorsanız, her makine için IP adreslerinize ve ana bilgisayar adlarınıza göre önceki tüm adımları izleyin.

VM’lerde IP Adreslerini ve Sunucu Adlarını Yapılandırma

Docker-nakivo31 ve docker-nakivo32 VM’lerinde (yukarıda gösterildiği gibi) IP adresini ve sunucu adını değiştirin.

Statik IP adreslerini ve ana bilgisayar adlarını yapılandırmak için yukarıdaki bölümlerde açıklanan adımları tekrarlayın.

IP adresi şu şekilde olmalıdır: 192.168.101.31 ve 192.168.101.32; worker node sunucu adlarının docker-nakivo31 ve docker-nakivo32 olması gerekir.

Tüm makinelerin, düğümlerin ana bilgisayar adlarını IP adreslerine çözümleyecek şekilde yapılandırılması gerekir. Bir DNS sunucusu yapılandırabilir veya her makinedeki hosts dosyasını manuel olarak düzenleyebilirsiniz.

Her makinedeki hosts dosyasına aşağıdaki dizeleri ekleyin (docker-nakivo21, docker-nakivo31, docker-nakivo32).

$ sudo vim /etc/hosts

Bu satırları hosts dosyasına ekleyin:

192.168.101.21 docker-nakivo21

192.168.101.31 docker-nakivo31

192.168.101.32 docker-nakivo32

Sunucu adlarının çözümlendiğinden emin olmak için her ana bilgisayardaki diğer ana bilgisayarlara ping atın:

$ ping docker-nakivo21

$ ping docker-nakivo31

$ ping docker-nakivo32

Tüm Sunucularda (VM’ler) SSH Erişimini Yapılandırma

Tüm sunucular için SSH erişimini yapılandırın. Her makinede komutları yürüterek OpenSSH sunucusunu kurun.

$ sudo apt-get install openssh-server

Kubernetes-user’ın ana dizinine gidin ve SSH anahtar çiftini (özel anahtar ve genel anahtardan oluşan bir dizi şifreleme anahtarı) oluşturun. SSH anahtar çiftleri, parola kullanmadan SSH aracılığıyla uzak Linux konsoluna erişmek için kullanılabilir. Genel anahtar, uzaktan bağlanmanız gereken bir makineye kopyalanabilirken, özel anahtar oldukça gizlidir ve bağlanmanız gereken makinede saklanması gerekir.

$ ssh-keygen

Anahtar oluşturmak için şifre girmenize gerek yoktur (şifre isteğe bağlıdır).

Anahtarları diğer Ubuntu makinelerine kopyalayın:

$ ssh-copy-id [email protected]

$ ssh-copy-id [email protected]

Anahtarların kopyalanmasını onaylamak için kullanıcı şifrenizi girin.

İkinci makineye (docker-nakivo31) kubernetes-user (yani normal bir kullanıcı) olarak bağlanmayı deneyin.

$ ssh ‘[email protected]’

Ardından üçüncü makineye (docker-nakivo32) bağlantıyı test edin.

$ ssh ‘[email protected]’

Başarılı bağlantıdan sonra konsolunuzun komut isteminde uzak makinenin adını göreceksiniz.

Uzak konsoldan çıkmak için Ctrl+D tuşlarına basın.

Root kullanıcı olarak SSH aracılığıyla bağlanma anahtarını nasıl kopyalarız?

Kubernetes’te root ayrıcalıklarına ihtiyacınız olacağından root için SSH erişimini yapılandırmak için anahtarlar oluşturalım. Root kullanıcısı olarak SSH üzerinden erişilmesi gereken tüm makinelerde (docker-nakivo21, docker-nakivo31 ve docker-nakivo32) aşağıdaki komutları çalıştırın.

$ sudo -i

SSH sunucusu yapılandırma dosyasını düzenleyin.

# vim /etc/ssh/sshd_config

Bu dosyaya aşağıdaki dizeyi ekleyin/düzenleyin.

PermitRootLogin yes

SSH sunucusu arka plan programını yeniden başlatın.

# /etc/init.d/ssh stop

# /etc/init.d/ssh start

Root parolasını ayarlayın (root kullanıcı için parola).

# passwd

$ cd /home/kubernetes-user/

$ sudo ssh-keygen -t rsa

SSH aracılığıyla root olarak uzaktan oturum açabilmek için genel anahtarı kopyalayın (önceki komut bu dizinden çalıştırıldığından beri anahtar, normal kullanıcının ana dizininde saklanır).

$ sudo ssh-copy-id -i /home/kubernetes-user/.ssh/id_rsa.pub 127.0.0.1

Anahtarınız kök kullanıcının ana dizinine kayıtlıysa anahtarı şu komutla kopyalayın:

# ssh-copy-id -i /root/.ssh/id_rsa.pub 127.0.0.1

Bu işlemi onaylayın ve şifrenizi girin.

Anahtarı her makineden diğer makinelere kopyalayarak işlemi tekrarlayın. Örneğin docker-nakivo21 makinesinde şunu çalıştırın:

# ssh-copy-id -i /root/.ssh/id_rsa.pub 192.168.101.31

# ssh-copy-id -i /root/.ssh/id_rsa.pub 192.168.101.32

Ortak anahtarı yetkilendirin.

# cat /root/.ssh/id_rsa.pub >> /root/.ssh/authorized_keys

Yerel makinede SSH aracılığıyla root olarak oturum açıp açamadığınızı doğrulayın.

$ sudo ssh [email protected]

Parola girmeden uzak makineye/makineye bağlanmayı deneyin.

$ sudo ssh [email protected]

$ sudo ssh [email protected]

$ sudo ssh [email protected]

Not: Kök kullanıcı olarak bağlanmak güvenli olmayabilir. Gerekmiyorsa root olarak bağlanmayın; normal bir kullanıcı olarak SSH aracılığıyla bağlanmak ve sudo komutunu kullanmak daha iyidir.

Docker Kurulumu

Docker, Kubernetes tarafından desteklenen en popüler kurumsal uygulama konteyneri platformudur. Docker’ı tüm makinelere yükleyin. Docker-nakivo21, docker-nakivo31, docker-nakivo32’de aşağıda gösterilen komutları çalıştırın.

Ancak acele etmeye gerek yok. İlk bakışta Docker’ı her zamanki komutu kullanarak kolayca kurabilirsiniz:

$ sudo apt-get install -y docker.io

Yine de bu durumda kullanılan Docker sürümü en son sürüm olmayabilir. Docker’ın en son sürümünü yükleyerek bu sorunu çözelim.

Öncelikle gerekli paketleri kurun.

$ sudo apt-get install apt-transport-https ca-certificates curl software-properties-common

Curl, desteklenen protokollerden birini (HTTP, HTTPS, FTP, FTPS, SFTP, LDAP, LDAPS, IMAP, IMAPS, POP3, POP3S, SCP, KOBİ, SMTP, TELNET vb.).

Resmi Docker deposunun GPG anahtarını Ubuntu sisteminize ekleyin:

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add –

Konsol çıkışının iyi olması gerekir.

Resmi Docker deposunu apt paket yöneticinize ekleyin:

$ sudo add-apt-repository “deb [arch=amd64] https://download.docker.com/linux/ubuntu bionic stable”

Önceki komutla manuel değişiklikler yapıldıktan sonra paket yöneticisinin veritabanını güncelleyin.

$ sudo apt-get update

Resmi depoda bulunan Docker paketinin sürümünü kontrol edin.

$ apt-cache policy docker-ce

Docker’ı yükleyin.

$ sudo apt-get install docker-ce

Docker sürümünü kurulumdan sonra kontrol edebilirsiniz.

$ docker –version

Bu durumda çıktı şu şekildedir: Docker sürüm 18.09.6, derleme 481bc77.

Docker’ı başlatın ve arka plan programını sistem başlangıcında otomatik olarak yüklenebilir hale getirin.

$ sudo systemctl start docker

$ sudo systemctl enable docker

Docker’ı tüm makinelere kurduktan sonra doğrudan Ubuntu üzerinde Kubernetes kurulumu adımına geçebilirsiniz.

Ubuntu’ya Kubernetes Kurulumu ve Küme Oluşturma

Artık hiçbir şey çekirdek Kubernetes bileşenlerini kurmanızı engellemiyor.

Kubernetes kümesine dahil edilecek tüm makinelerde komutları root olarak çalıştırın.

$ sudo -i

Resmi Docker deposunun GPG anahtarını Ubuntu sisteminize ekleyin:

# curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add –

Resmi Kubernetes deposunu, apt paket yöneticiniz için mevcut paket depolarının veritabanına ekleyin.

# cat <<EOF >/etc/apt/sources.list.d/kubernetes.list

deb http://apt.kubernetes.io/ kubernetes-xenial main

EOF

Alternatif olarak depoyu şu komutla ekleyebilirsiniz:

# echo ‘deb http://apt.kubernetes.io/ kubernetes-xenial main’ | sudo tee /etc/apt/sources.list.d/kubernetes.list

tee, standart girişi okuyan ve giriş verilerini standart çıktıya ve tanımlanmış dosyalara yazan bir araçtır.

Ubuntu sisteminizdeki mevcut depoların paket listesini güncelleyin.

# apt-get update

Kubernetes’i Ubuntu’ya kurmak için kubectl, kubeadm ve kubectl’i kurmak çok önemlidir.

# apt-get install -y kubelet kubeadm kubectl

Keepalived’i yükleyin.

# apt-get install keepalived

# systemctl enable keepalived && systemctl start keepalived

Ubuntu’da kurulu Kubernetes’in doğru çalışması için değerin 1 olup olmadığını doğrulayın.

# sysctl net.bridge.bridge-nf-call-iptables

Bu değeri 1’e ayarlamak için şu komutu çalıştırın:

sysctl net.bridge.bridge-nf-call-iptables=1

Kubeadm yapılandırma dosyasını düzenleyin.

# vim /etc/systemd/system/kubelet.service.d/10-kubeadm.conf

Dizeyi mevcut Ortam dizesinden sonra ekleyin:

Environment=”cgroup-driver=systemd/cgroup-driver=cgroupfs”

Cgroup’lar işlemci, bellek, disk giriş/çıkış, ağ gibi kaynak kullanımını izole eden kontrol gruplarıdır.

Master node üzerindeki (docker-nakivo21), Ubuntu’da Kubernetes kümesini başlatmak için komutu çalıştırın.

# kubeadm init –pod-network-cidr=10.244.0.0/16 –apiserver-advertise-address=192.168.101.21

Parametreler:

–pod-network-cidr Flanel sürücüsü için gereklidir. CIDR (Sınıfsız Etki Alanları Arası Yönlendirme), yer paylaşımlı ağınızın (Flannel gibi) daha sonra yapılandırılacak adresini tanımlar. Ağ maskesi ayrıca düğüm başına kaç bölmenin çalıştırılabileceğini de tanımlar. CIDR ağ adresi ve Flannel için kullanılan ağ adresi aynı olmalıdır.

–apiserver-advertise-address=192.168.101.21 Kubernetes tarafından API sunucusu olarak tanıtılacak IP adresini tanımlar.

Çıktıyı okuyun ve metnin sonunda görüntülenen komutları kaydedin. Bu önemli bir nokta. Oluşturulan jeton, Kubernetes kümesine çalışan düğümlerin eklenmesi için gereklidir.

Aşağıdaki komutları kubeadm init çalıştıran bir kullanıcı olarak çalıştırın. Bu durumda komutlar root olarak yürütülür.

# mkdir -p $HOME/.kube

# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config

# sudo chown $(id -u):$(id -g) $HOME/.kube/config

Bu komutları çalıştırmazsanız Kubernetes şu hatayı döndürecektir: Sunucu localhost:8080 ile bağlantı reddedildi – doğru sunucuyu veya bağlantı noktasını belirttiniz mi?

Kubernetes bu yapılandırma dosyasını kullanıcı dizinine otomatik olarak kopyalamaz. Bu işlemi manuel olarak gerçekleştirmelisiniz.

Kümeye eklenen node’ları kontrol edin

# kubectl get nodes

Ubuntu’da kurulu olan Kubernetes kümesinde NotReady durumuna sahip bir master node görebilirsiniz. Bunun nedeni, yer paylaşımlı ağın yapılandırılmamış olmasıdır. Kubernetes master node’un Hazır Değil durumunu düzeltmek için Flannel’ı yapılandırın. Docker ve Kunernetes için yaml dosyalarını depolamak üzere dizin oluşturun; örneğin /home/kubernetes-user/kubernetes/

YAML , Kubernetes’te pod ve dağıtımlar oluştururken size daha fazla kolaylık sunar. Her komutu Linux konsolunda manuel olarak çalıştırmak yerine, dağıtılması gereken konteynerlerin tüm parametrelerini YAML yapılandırma dosyasında tanımlayabilirsiniz. YAML dosyalarına Kubernetes bağlamında bildirim dosyaları da denir.

Aşağıdaki içeriğe sahip yaml yapılandırma dosyasını oluşturun:

kube-flannel.yml

Komutu çalıştır

# kubectl apply -f ./kube-flannel.yml

Alternatif olarak GitHub’da Kubernetes için hazırlanmış ücretsiz YAML dağıtım yapılandırması örneklerini bulabilirsiniz.

kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/a70459be0084506e4ec919aa1c114638878db11b/Documentation/kube-flannel.yml

Ubuntu’da dağıttığınız Kubernetes kümesine eklenen düğümleri kontrol edin:

# kubectl get nodes

Ana düğümün durumu artık Hazırdır.

Flanel’in doğru şekilde kurulduğundan emin olun:

# kubectl get pods –all-namespaces

Flanel podunun çalıştığını görebilirsiniz. Bu pod iki konteynerden oluşur: Flannel arka plan programı ve CNI yapılandırmasını Kubernetes için okunabilir bir konuma dağıtmak için kullanılan initContainer.

Bazen Kubernetes’i Ubuntu’ya yüklediğinizde aşağıdaki hata ortaya çıkabilir:

Unable to connect to the server: net/http: TLS handshake timeout.

Bu sorunu nasıl düzeltebilirsiniz? Birkaç saniye bekleyin ve tekrar deneyin; bu genellikle yeterlidir.

Ad alanları, Kubernetes kümesindeki küme kaynaklarını temsil eden ve sanal kümeler olarak değerlendirilebilecek mantıksal varlıklardır. Bir fiziksel küme mantıksal olarak birden fazla sanal kümeye bölünebilir. Varsayılan Kubernetes ad alanları Varsayılan, Kube-public ve Kube-system’dir. Ad alanlarının listesini alabilirsiniz:

# kubectl get namespaces

Hatırlayacağınız gibi Kubernetes’teki temel dağıtım birimi, ağı paylaşan ve ad alanını bağlayan bir konteynerler koleksiyonu olan bir poddur. Pod’un tüm konteynerleri aynı Kubernetes düğümünde planlanır. Mevcut podları kontrol edin:

# kubectl -n kube-system get pods

Kümeyi sıfırlamak/durdurmak istiyorsanız şu komutu çalıştırın:

# kubeadm reset

Master node üzerinde her şey yolunda. Bu, artık Kubernetes’i Ubuntu’ya yüklemeye devam edebileceğiniz ve kümeye worker nodeları eklemeye geçebileceğiniz anlamına gelir.

Worker node’lar üzerinde (docker-nakivo31, docker-nakivo32) şu komutu çalıştırın:

# kubeadm join 192.168.101.21:6443 –token d8mbzb.uulxu01jbty8yh4z \

–discovery-token-ca-cert-hash sha256:65ace7a4ff6fff795abf086f18d5f0d97da71d4639a0d0a6b93f42bea4948a79

Hatırlayacağınız gibi token ve hash bilgileri, kubeadm init komutuyla küme başlatıldıktan sonra not edilmiş olmalıydı.

Master node üzerinde küme durumunu tekrar kontrol edin.

# kubectl get nodes

Artık Ubuntu makinelerinde çalışan Kubernetes kümesinde bir master ve iki worker node’u görebilirsiniz.

Kubernetes yapılandırmasını kontrol edebilirsiniz:

# kubectl cluster-info

Kubernetes’te Pod Dağıtımı

Artık Kubernetes kümenizde konteynerler içeren bir pod dağıtabilirsiniz. Hatırlayacağınız üzere Kubernetes’te konteynerler pod’ların içerisinde yer alıyor. Yaml dosyaları kullanıyorsanız, daha fazla kolaylık sağlamak amacıyla bu dosyaları saklayacak bir dizin oluşturun. Bu dizine gidin ve kubectl application -f test.yaml gibi komutları çalıştırın.

Flannel yapılandırılırken böyle bir dizin zaten oluşturulmuştur – /home/kubernetes-user/kubernetes/

Yeni bir pod konuşlandırmanın zamanı geldi. Öncelikle bir dağıtım oluşturmanız gerekir. Dağıtım, podlara ve çoğaltma kümelerine bildirim temelli güncellemeler sağlamak için kullanılan bir denetleyici konseptidir. Tek bir komutla veya yaml dosyalarını kullanarak dağıtım oluşturabilirsiniz.

Örnek 1 – MySQL’in dağıtılması

Bu örnekte bir yaml dosyası oluşturalım. Dosyanın adı mysql-deployment.yaml’dir

Yapılandırmayı görüntülemek için ekteki dosyaya bakın.

# vim mysql-deployment.yaml

Kubectl ile kaynakları yönetmek için iki popüler yaklaşım vardır. Kubectl create ve kubectl application arasındaki fark nedir? Kubectl create’i kullanırken Kubernetes’e neyi oluşturmak, değiştirmek veya silmek istediğinizi söylersiniz; bu komut tüm değişikliklerin üzerine yazar. Alternatif olarak kubectl application, artımlı değişiklikler yapar ve bu komut, canlı bir nesneye uygulanan değişiklikleri kaydetmek için kullanılabilir.

Bir dağıtım oluşturun:

# kubectl apply -f ./mysql-deployment.yaml

Kubernetes, dağıtımınızla ilgili bilgileri görüntüleyebilir.

# kubectl describe deployment mysql

Podları kontrol edin:

# kubectl get po

veya

# kubectl get pods

veya

# kubectl get pods -l app=mysql

Pod’un bekleme durumunu görüyorsanız bu, yeterli bilgi işlem kaynağının olmadığı anlamına gelebilir. Pod’un Kubernetes’teki bekleme durumunu düzeltmek için bir miktar CPU ve bellek kapasitesi eklemeyi deneyin.

Gerekirse hizmeti silebilirsiniz:

# kubectl delete service <service_name>

Ayrıca bir pod’u da silebilirsiniz:

# kubectl delete pod mysql-7b9b7999d8-nz5tm

Örnek 2 – Nginx’i dağıtma

Yaml dosyaları olmadan başka bir yöntem kullanarak nginx’i dağıtalım.

Bir dağıtım oluşturun.

# kubectl create deployment nginx –image=nginx

Dağıtımın oluşturulduğunu kontrol edin.

# kubectl get deployments

Bir servis oluşturun.

# kubectl create service nodeport nginx –tcp=80:80

Bir servis şu hizmet türleri kullanılarak oluşturulabilir: ClusterIP, NodePort, LoadBalance ve HariciAd. NodePort tipi kullanılıyorsa, sağlanan servislere erişim için 30000-32767 aralığından rastgele bir bağlantı noktası tahsis edilir. Bu porta gönderilen trafik gerekli servise iletilir.

Hizmetin oluşturulduğunu ve tanımlanan bağlantı noktasını dinlediğini kontrol edin.

# kubectl get svc

Bağlantı noktası numarasını unutmayın (bu durumda 31453).

Servisinizi dağıtılıp dağıtılmadığını ve kullanılabilir olup olmadığını kontrol edin (bu örnekte komut master nod’da çalıştırılır). Önceki adımdan hatırladığınız node’un ve bağlantı noktasının sunucu adını kullanın.

# curl docker-nakivo31:31453

Ayrıca servisin herhangi bir node’un tarayıcısından erişilebilir olup olmadığını da kontrol edebilirsiniz. Web tarayıcısının adres çubuğundaki sayfaları ziyaret etmeyi deneyin:

http:// 10.101.235.90

veya

http://docker-nakivo31:31453

http://docker-nakivo32:31453

Her şey yolundaysa nginx karşılama sayfasını göreceksiniz.

Ayrıca Kubernetes node’larının bağlı olduğu ağa erişimi olan herhangi bir makineden (192.168.101.0/24) nginx test sayfasını ziyaret etmek de mümkündür . Örneğin, web sayfalarını tarayıcınızla ziyaret edebilirsiniz:

http://192.168.101.21:31453/

http://192.168.101.31:31453/

http://192.168.101.32:31453/

Kubernetes’i İzlemek için Web Arayüzünü Ayarlama

Kubernetes’in Ubuntu’ya kurulumu neredeyse tamamlandı ancak daha fazla rahatlık için Kubernetes kontrol panelini de kurabilirsiniz. Kubernetes kontrol paneli, Kubernetes yönetimi ve izlenmesine yönelik bir web arayüzüdür. Kontrol panelini yüklemek için, daha önce komutları çalıştırmadan önce yaptığınız gibi kubernetes-dashboard.yaml dosyasını oluşturun.

# kubectl create -f ./kubernetes-dashboard.yaml

# kubectl apply -f ./kubernetes-dashboard.yaml

Podları kontrol edin.

# kubectl get pods -o wide –all-namespaces

Kubernetes API sunucusuna proxy’yi başlatın.

# kubectl proxy

Konsola sonraki komutları girmek için lütfen başka bir konsol penceresi açın. Aksi takdirde süreç sonlandırılacaktır.

Ana düğümdeki web tarayıcınızda şu sayfaya gidin:

http://localhost:8001

Test sayfasını görebilirsiniz.

Tam adresi web tarayıcısının adres çubuğuna girin.

http://localhost:8001/api/v1/namespaces/kube-system/services/https:kubernetes-dashboard:/proxy/

Yeni konsol penceresinde komutları yürüterek hizmet hesabıyla bir kontrol paneli oluşturun.

# kubectl create serviceaccount dashboard -n default

# kubectl create clusterrolebinding dashboard-admin -n default \

–clusterrole=cluster-admin \

–serviceaccount=default:dashboard

# kubectl get secret $(kubectl get serviceaccount dashboard -o jsonpath=”{.secrets[0].name}”) -o jsonpath=”{.data.token}” | base64 –decode

Artık oluşturulan jetonu görebilirsiniz:

Oluşturulan jetonu kopyalayın ve kontrol panelinde oturum açmak için web arayüzünün jeton bölümüne yapıştırın.

Aşağıdaki ekran görüntüsünde Kubernetes kontrol panelinin web arayüzünü görebilirsiniz. Nodeların, dağıtımların ve podların durumunu görebilir, ayrıca rolleri, depolama sınıflarını ve diğer bileşenleri kontrol edebilirsiniz.

İzleme Aracını Heapster’ı Kurun

CPU, bellek ve diğer izleme parametrelerini ekleyerek Kubernetes kontrol panelinin izleme seçeneklerini genişletmek için Heapster’ı yükleyin. Adı heapster.yaml olan bir bildirim dosyası oluşturun.

# vim heapster.yaml

Bir sonraki eylemde Heapster’ı konuşlandırın.

# kubectl create -f heapster.yaml

Heapster’ın RBAC (rol tabanlı erişim kontrolü) rolünü düzenleyin ve node’larn istatistiklerine erişim izinleri ekleyin.

# kubectl edit clusterrole system:heapster

Konsolda CPU ve bellek ölçümlerinin ölçülüp ölçülemediğini kontrol edin.

# kubectl top node

Artık Kubernetes Dashboard’un web arayüzünü açabilir ve CPU kullanımı ve bellek kullanımı grafikleri dahil bazı bölümlerin eklendiğini görebilirsiniz.

Kubernetes kümeniz artık yapılandırılmıştır ve çalışmaya hazırdır.

Ubuntu’da Yüksek Kullanılabilirliğe Sahip bir Kubernetes Kümesini Birden Çok Yöneticiyle Dağıtma

Bir master node ve birkaç worker node’a sahip bir Kubernetes kümesine sahip olmak iyi bir seçenektir ancak bazen varolan master node, donanım sorunları veya güç kaybı gibi nedenlerle arızalanabilir. Ubuntu nodelara dağıtılan Kubernetes kümesinin daha yüksek hata toleransı için Yüksek Kullanılabilirlik Kubernetes kümesini birden fazla master node’la dağıtmayı düşünmek daha iyidir. Bu Kubernetes küme dağıtım modelini kullanmak, tek bir hata noktasından kaçınmanıza olanak tanır. Tek sayıda master node kullanmanız önerilir ve hata toleransı sağlayabilecek minimum ana master node sayısı üçtür. Üçten fazla master node kullanıyorsanız ve node sayısı eşitse tüm kümenin hata toleransı artmaz. Kubernetes kümesindeki master node sayısına bağlı olarak hata toleransı değerini karşılaştırmak için aşağıdaki tabloya bakın. Örneğin, 5 master nodedan oluşan bir kümeniz varsa, üç master node çalışmaya devam ettiği için küme 2 master node’un başarısızlığından kurtulabilir (5’ten 3’ü %50’den fazladır ve çoğunluğu oluşturur). Küme boyutu, kümedeki master node sayısını ifade eder.

Bugünkü blog gönderisinin bu bölümü, Kubernetes Yüksek Kullanılabilirlik kümesinin, HA proxy’sinin ve bazı çalışan düğümlerin dağıtımı çerçevesinde Kubernetes’in Ubuntu nodelara nasıl kurulacağını araştırıyor. Aşağıdaki tabloda, bu örnekte açıklanan test laboratuvarındaki Ubuntu nodelara HA Kubernetes kümesinin kurulumu için kullanılan sunucu IP adreslerini, sunucu adlarını ve rollerini görebilirsiniz.

Bazı komutlar, tek master node modelini kullanarak Kubernetes’i Ubuntu’ya yüklemekle aynıdır. Bu nedenle bazı komutlara ilişkin açıklamalar tekrarlanmamaktadır. Komutların açıklamasını hatırlamak için bu sayfayı yukarı kaydırabilirsiniz.

Aşağıdakileri yaparak tüm makineleri (HA proxy, master ve worker node’lar) Kubernetes’i yüklemek için hazırlayın:

• Statik IP adreslerini yapılandırın.
• Ana bilgisayar adlarını ayarlayın. Tüm sunucu adları IP adreslerine çözümlenmelidir.
• SSH erişiminin sertifikalar kullanılarak etkinleştirilmesi ve yapılandırılması gerekir.
• Takas devre dışı bırakılmalıdır.

Bu adımların, her makinede Docker kurulumuna başlamadan önce yapılması gerekir; tıpkı yukarıdaki bölümde okuduklarınıza benzer şekilde, Kubernetes’i Ubuntu’ya tek bir master node kullanarak kurarken anlatılmıştı. Tüm makineleri hazırladıktan sonra (192.168.101.19) adresine gidin.

HA Proxy Yük dengeleyicisini yapılandırma

HA Proxy yük dengeleyici, giriş trafiğini Kubernetes nodeları arasında dağıtmak için kullanılır. Yük dengeleyici master nodeların önüne konumlandırılır. ha-proxy19 makinesinin konsolunu açın ve aşağıda gösterilen eylemleri gerçekleştirin.

CFssl’yi yükleyin

Cfssl (Cloud Flare SSL), TLS/SSL sertifika zincirleri dahil farklı sertifikalar oluşturmak için kullanılan bir araç setidir.

İkili dosyaları resmi depodan indirin.

# wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64

# wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64

İndirilen ikili dosyaları yürütülebilir hale getirin.

# chmod +x cfssl*

Bu ikili dosyaları /usr/local/bin/ dizinine taşıyın

# mv cfssl_linux-amd64 /usr/local/bin/cfssl

# mv cfssljson_linux-amd64 /usr/local/bin/cfssljson

Kurulu cfssl sürümünü kontrol ederek kurulumu doğrulayın.

# cfssl version

Depo dizinini güncelleyin.

# apt-get update

HA proxy’sini yükleyin.

# apt-get install haproxy

haproxy.cfg dosyasını oluşturun ve düzenleyin.

# vim /etc/haproxy/haproxy.cfg

Bu satırları bu yapılandırma dosyasının sonuna ekleyin.

frontend kubernetes

bind 192.168.101.19:6443

option tcplog

mode tcp

default_backend kubernetes-master-nodes

backend kubernetes-master-nodes

mode tcp

balance roundrobin

option tcp-check

server docker-nakivo21 192.168.101.21:6443 check fall 3 rise 2

server docker-nakivo22 192.168.101.22:6443 check fall 3 rise 2

server docker-nakivo23 192.168.101.23:6443 check fall 3 rise 2

Servisi yeniden başlatın.

# systemctl restart haproxy

TSL sertifikaları oluşturun

HA proxy makinesinin konsolunu kullanmaya devam edebilirsiniz. Ca-config.json adlı sertifika yetkilisi yapılandırma dosyasını oluşturun.

# vim ca-config.json

Bu yapılandırma dosyasına aşağıdaki içeriği ekleyin:

{

“signing”: {

“default”: {

“expiry”: “8760h”

},

“profiles”: {

“kubernetes”: {

“usages”: [“signing”, “key encipherment”, “server auth”, “client auth”],

“expiry”: “8760h”

}

}

}

}

Sertifika yetkilisi imzalama isteği yapılandırma dosyasını oluşturun.

# vim ca-csr.json

İçeriği bu dosyaya aşağıda gösterildiği gibi ekleyin:

{

“CN”: “Kubernetes”,

“key”: {

“algo”: “rsa”,

“size”: 2048

},

“names”: [

{

“C”: “GB”,

“L”: “London”,

“O”: “Kubernetes”,

“OU”: “CA”,

“ST”: “Nakivo”

}

]

}

Parametreler:

C – ülke, örneğin, GB (Büyük Britanya).

L – şehir veya kasaba gibi konum.

O – organizasyon.

OU – organizasyon birimi (örneğin, anahtar sahibi olarak tanımlanan bir departman).

ST – eyalet veya il.

Şimdi ve özel anahtarı oluşturun.

# cfssl gencert -initca ca-csr.json | cfssljson -bare ca

Ca-key.pem ve ca.pem anahtarlarının oluşturulduğunu doğrulayın.

# ls -al

Etcd kümesi için sertifika oluşturma

Etcd, istemci sertifikaları aracılığıyla kimlik doğrulamayı kullanarak sunucudan sunucuya/küme iletişimini destekler. Bir küme üyesi için bir CA sertifikasına ve imzalı bir anahtar çiftine sahip olmanız gerekir.

Sertifika imzalama isteği yapılandırma dosyasını oluşturun.

# vim kubernetes-csr.json

{

“CN”: “kubernetes”,

“key”: {

“algo”: “rsa”,

“size”: 2048

},

“names”: [

{

“C”: “GB”,

“L”: “London”,

“O”: “Kubernetes”,

“OU”: “Kubernetes”,

“ST”: “Nakivo”

}

]

}

Bundan sonra sertifikayı ve özel anahtarı oluşturun.

# cfssl gencert \

-ca=ca.pem \

-ca-key=ca-key.pem \

-config=ca-config.json \

-hostname=192.168.101.21,192.168.101.22,192.168.101.23,192.168.101.19,127.0.0.1,kubernetes.default \

-profile=kubernetes kubernetes-csr.json | \

cfssljson -bare kubernetes

kubernetes-key.pem ve kubernetes.pem dosyasının oluşturulduğunu doğrulamak için dizininizdeki dosyaları listeleyin.

# ls -al

Oluşturulan sertifikayı her düğüme kopyalayın.

# scp ca.pem kubernetes.pem kubernetes-key.pem [email protected]:~

# scp ca.pem kubernetes.pem kubernetes-key.pem [email protected]:~

# scp ca.pem kubernetes.pem kubernetes-key.pem [email protected]:~

# scp ca.pem kubernetes.pem kubernetes-key.pem [email protected]:~

# scp ca.pem kubernetes.pem kubernetes-key.pem [email protected]:~

# scp ca.pem kubernetes.pem kubernetes-key.pem [email protected]:~

~, Ubuntu ana bilgisayarlarındaki kubernetes kullanıcısının ana dizinidir.

Kubernetes’i yüklemek için Ubuntu düğümlerini hazırlama

Bu bölümde gösterilen komutları tüm master ve worker nodelarda çalıştırın. Docker’ı kurun, ardından Kubernetes kümesine dahil edilecek Ubuntu makinelerine Kubernetes’i yükleyin. 192.168.101.21 master node’u hazırlamakla başlayalım.

Docker’ı yükleyin.

# apt-get install apt-transport-https ca-certificates curl software-properties-common

# curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add –

# add-apt-repository “deb [arch=amd64] https://download.docker.com/linux/ubuntu bionic stable”

# apt-get update

# apt-get install docker-ce

Docker artık kuruldu. Cubeadm, kublet ve cubectl, Kubernetes’i Ubuntu’ya kurmak için gereken Kubernetes bileşenleridir.

Kubernetes bileşenlerini (kubeadm, kublet ve kubectl) yükleyin.

# curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add –

# echo ‘deb http://apt.kubernetes.io/ kubernetes-xenial main’ | sudo tee /etc/apt/sources.list.d/kubernetes.list

# apt-get update

# apt-get install -y kubelet kubeadm kubectl

Tüm node’ları hazırlayıp Docker, kubelet, kubeadm ve kubectl’i yükledikten sonra, master node’larda etcd’yi kurup yapılandırmanız gerekir.

Ubuntu master node üzerinde etcd’yi yükleme ve yapılandırma

Etcd, anahtarların saklanması ve tüm küme verilerinin yedeklenmesi için tasarlanmış, tutarlı ve yüksek oranda kullanılabilir bir mağazadır. HA Kubernetes kümesini birden çok ana düğümle yapılandırmadan önce etcd kümesinin kurulması gerekir. 192.168.101.21 ana düğümünü yapılandırmakla başlayalım.

Installing and configuring etcd on the 192.168.101.21 machine.

Etcd için bir yapılandırma dizini oluşturun.

# mkdir /etc/etcd /var/lib/etcd

Sertifikaların kopyalandığı dizine gidin. Bu, kubernetes kullanıcısının ana dizini, bu durumda – /home/kubernetes-user/

Sertifikaları etcd yapılandırma dizinine kopyalayın.

# cp ca.pem kubernetes.pem kubernetes-key.pem /etc/etcd

Dosyaların kopyalandığını doğrulayın.

# ls -al /etc/etcd

Önceki dizininize geri dönün

# cd –

Depodan etcd ikili dosyalarını indirin.

# wget https://github.com/coreos/etcd/releases/download/v3.3.9/etcd-v3.3.9-linux-amd64.tar.gz

Etcd arşivini çıkarın.

# tar xvzf etcd-v3.3.9-linux-amd64.tar.gz

Şimdi etcd ikili dosyalarını /usr/local/bin/ dizinine taşıyın

# mv etcd-v3.3.9-linux-amd64/etcd* /usr/local/bin/

Bir etcd systemd birim dosyası oluşturun.

# vim /etc/systemd/system/etcd.service

Aşağıda gösterilen dizeleri bu dosyaya ekleyin.

[Unit]

Description=etcd

Documentation=https://github.com/coreos

[Service]

ExecStart=/usr/local/bin/etcd \

–name 192.168.101.21 \

–cert-file=/etc/etcd/kubernetes.pem \

–key-file=/etc/etcd/kubernetes-key.pem \

–peer-cert-file=/etc/etcd/kubernetes.pem \

–peer-key-file=/etc/etcd/kubernetes-key.pem \

–trusted-ca-file=/etc/etcd/ca.pem \

–peer-trusted-ca-file=/etc/etcd/ca.pem \

–peer-client-cert-auth \

–client-cert-auth \

–initial-advertise-peer-urls https://192.168.101.21:2380 \

–listen-peer-urls https://192.168.101.21:2380 \

–listen-client-urls https://192.168.101.21:2379,http://127.0.0.1:2379 \

–advertise-client-urls https://192.168.101.21:2379 \

–initial-cluster-token etcd-cluster-0 \

–initial-cluster 192.168.101.21=https://192.168.101.21:2380,192.168.101.22=https://192.168.101.22:2380,192.168.101.23=https://192.168.101.23:2380 \

–initial-cluster-state new \

–data-dir=/var/lib/etcd

Restart=on-failure

RestartSec=5

[Install]

WantedBy=multi-user.target

Değiştirilen yapılandırmaları dosya sisteminden almak ve bağımlılık ağaçlarını yeniden oluşturmak için sistem yöneticisi yapılandırmasını yeniden yükleyin.

# systemctl daemon-reload

Önyükleme sırasında etcd’nin başlatılmasını sağlayın.

# systemctl enable etcd

etcd ‘yi başlatın.

# systemctl start etcd

Aynı işlemleri ikinci master node üzerinde de yapın (docker-nakivo22 – 192.168.101.21 ve docker-nakivo23 – 192.168.101.22). Bu master node için gereken eylemlerdeki tek fark,etcd.service yapılandırma dosyasının düzenlenmesidir. Birbirinizin master node için doğru IP adreslerini tanımlayın. Örneğin, mevcut Kubernetes test laboratuvarının ikinci master node’u (192.168.101.22) için etcd.service yapılandırma dosyası aşağıdaki gibi olmalıdır.

[Unit]

Description=etcd

Documentation=https://github.com/coreos

[Service]

ExecStart=/usr/local/bin/etcd \

–name 192.168.101.22 \

–cert-file=/etc/etcd/kubernetes.pem \

–key-file=/etc/etcd/kubernetes-key.pem \

–peer-cert-file=/etc/etcd/kubernetes.pem \

–peer-key-file=/etc/etcd/kubernetes-key.pem \

–trusted-ca-file=/etc/etcd/ca.pem \

–peer-trusted-ca-file=/etc/etcd/ca.pem \

–peer-client-cert-auth \

–client-cert-auth \

–initial-advertise-peer-urls https://192.168.101.22:2380 \

–listen-peer-urls https://192.168.101.22:2380 \

–listen-client-urls https://192.168.101.22:2379,http://127.0.0.1:2379 \

–advertise-client-urls https://192.168.101.22:2379 \

–initial-cluster-token etcd-cluster-0 \

–initial-cluster 192.168.101.21=https://192.168.101.21:2380,192.168.101.22=https://192.168.101.22:2380,192.168.101.23=https://192.168.101.23:2380 \

–initial-cluster-state new \

–data-dir=/var/lib/etcd

Restart=on-failure

RestartSec=5

[Install]

WantedBy=multi-user.target

Kubernetes HA kümesindeki master node’ları başlatma

Artık Ubuntu makinelerinde kurulu Kubernetes HA kümenizdeki master nodeları başlatabilirsiniz.

Initializing the 192.168.101.21 master node

İlk master node’da aşağıda açıklanan işlem kapsamını gerçekleştirin.

Kubeadm için yaml yapılandırma dosyasını oluşturun.

# vim config.yaml

Yapılandırma parametrelerini bu dosyaya ekleyin:

apiVersion: kubeadm.k8s.io/v1alpha3

kind: ClusterConfiguration

kubernetesVersion: stable

apiServerCertSANs:

– 192.168.101.19

controlPlaneEndpoint: “192.168.101.19:6443”

etcd:

external:

endpoints:

– https://192.168.101.21:2379

– https://192.168.101.22:2379

– https://192.168.101.23:2379

caFile: /etc/etcd/ca.pem

certFile: /etc/etcd/kubernetes.pem

keyFile: /etc/etcd/kubernetes-key.pem

networking:

podSubnet: 10.244.0.0/16

apiServerExtraArgs:

apiserver-count: “3”

PodSubnet (10.244.0.0/16) olarak tanımlanan ağ, kube-flannel.yml dosyasındaki ile aynı olmalıdır.

Ubuntu makinesini master node olarak başlatın.

# kubeadm init –config=config.yaml

Bazen bir yapılandırma dosyasının eski sürümüyle ilgili bir uyarı görebilirsiniz:

Yapılandırma dosyanız kullanımdan kaldırılmış bir API spesifikasyonu kullanıyor: “kubeadm.k8s.io/v1alpha3”. Lütfen daha yeni bir API sürümü kullanarak yeni, benzer spesifikasyonu yazacak olan ‘kubeadm config merge –old-config old.yaml –new-config new.yaml’ komutunu kullanın.

Yapılandırma dosyasının sürümünü şu komutla güncelleyin:

# kubeadm config migrate –old-config config.yaml –new-config config1.yaml

Çok yöneticili Kubernetes kümesinin bir düğümünü başlattığınızda, etcd çalışmıyorsa başka bir hata ortaya çıkabilir:

[ERROR ExternalEtcdVersion]: Get https://192.168.101.21:2379/version: dial tcp 192.168.101.21:2379: connect: connection refused

Etcd’nizin çalışıp çalışmadığını kontrol edin. Etcd’yi manuel olarak çalıştırabilirsiniz:

# systemctl start etcd

Ubuntu üzerinde çalışan Kubernetes kümesindeki master node’un başarılı bir şekilde başlatılmasının ardından, ekran görüntüsünde gösterildiği gibi aşağıdaki mesajı alırsınız.

Bu komutun başarılı bir şekilde yürütülmesinin çıktısı, kümenizi nasıl kullanmaya başlayacağınıza dair bir ipucunun yanı sıra, nodeları kümeye birleştirmek için gereken bir belirteç ve sertifika karmasını içeren komutları içerir. Bu önemli dizeleri saklayın çünkü yakında bunlara ihtiyacınız olacak. Ekran görüntüsünde sarı renkle işaretlenmiştir ve aşağıda kopyalanmıştır.

Artık sertifika yetkililerini kopyalayarak istediğiniz sayıda kontrol düzlemi düğümüne katılabilirsiniz

ve her node’daki servis hesabı anahtarlarını ve ardından aşağıdakileri root olarak çalıştırmayı deneyin:

kubeadm join 192.168.101.19:6443 –token sxm34y.p4rn4328vne0iihf \

–discovery-token-ca-cert-hash sha256:bf3887f1565fcd48ff696da98a761ac1b70c6d38ba0ba3e4b1bf573000a302ca \

–experimental-control-plane

Daha sonra aşağıdakileri her birinde root olarak çalıştırarak istediğiniz sayıda worker node’a katılabilirsiniz:

kubeadm join 192.168.101.19:6443 –token sxm34y.p4rn4328vne0iihf \

–discovery-token-ca-cert-hash sha256:bf3887f1565fcd48ff696da98a761ac1b70c6d38ba0ba3e4b1bf573000a302ca

Kümede başlatılan düğümü kullanmaya başlamak için komutları çalıştırın.

# mkdir -p $HOME/.kube

# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config

# sudo chown $(id -u):$(id -g) $HOME/.kube/config

Kümeye eklenen nodeları kontrol edin.

# kubectl get nodes

Sertifikaları diğer iki master node’a kopyalayın

# scp -r /etc/kubernetes/pki [email protected]:~

# scp -r /etc/kubernetes/pki [email protected]:~

Initializing the 192.168.101.22 master node

Komutları ikinci master node üzerinde (192.168.101.22) çalıştırın.

Kubernetes-user’ın ana dizininde (~) bulunan apiserver.crt ve apserver.key’i kaldırın.

$ rm ~/pki/apiserver.*

Ana dizinde saklanan sertifikaları /etc/kubernetes/ dizinine taşıyın.

$ sudo mv ~/pki /etc/kubernetes/

Kubeadm için yapılandırma yaml dosyasını oluşturun.

# vim config.yaml

Bu yaml dosyasının içeriği ilk master node (192.168.101.21) ile aynıdır. Yukarıdaki ilk master node’un başlatılmasına ilişkin konfigürasyona bakın. Ubuntu makinelerinizde kurulu olan Kubernetes HA kümesinin ilk master node’da kullanılan önceden oluşturulmuş dosyayı kopyalayabilirsiniz.

İkinci master node’u başlatın.

# kubeadm config migrate –old-config config.yaml –new-config config1.yaml

# kubeadm init –config=config1.yaml

Çıktı, Kubernetes HA kümesindeki ilk master node başlatıldıktan sonra görüntülenen çıktıyla aynıdır:

Benzer şekilde, kümedeki başlatılan node’u kullanmaya başlamak için komutları yürütün.

# mkdir -p $HOME/.kube

# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config

# sudo chown $(id -u):$(id -g) $HOME/.kube/config

Kümeye eklenen düğümleri kontrol edin.

# kubectl get nodes

Kümeye üç ana düğümden ikisi eklendi. Eklenecek bir master node kaldı.

Initializing the third (192.168.101.23) master node

Kümedeki ikinci node (192.168.101.22) başlatmak için yaptığınız adımların aynısını tekrarlayın.

Master node başlatıldıktan sonra görüntülenen kümeye node eklemek için belirteç ve karma komutları not etmeyi unutmayın.

Üç master node’un tamamının kümeye başarıyla eklendiğini kontrol edin.

# kubectl get nodes

Kubernetes’teki ana düğümlerin Hazır Değil durumunu düzeltmek için Flannel’ı yükleme

Flannel’ı kuralım. Tek bir ana küme oluşturmak için Kubernetes’i Ubuntu’ya nasıl kuracağınızı öğrendiğiniz ilk örnekten farklı olarak, bu örnekte Flannel, yaml dosyası kullanılarak kurulacaktır.

Henüz yapılandırılmış bir yer paylaşımlı ağ olmadığından, Flannel’ı yüklemek ve görüntülenen nodeların Hazır Değil durumunu düzeltmek için komutu çalıştırın. Örneğin ilk master node’da vim metin düzenleyicisiyle kube-flannel.yaml dosyasını oluşturun.

# kubectl apply -f kube-flannel.yml

Config.yaml dosyasında tanımlanan podSubnet adresini unutmayın. kube-flannel.yaml dosyasındaki ağ adresi aynı olmalıdır.

Nodeları ve durumlarını kontrol edin.

# kubectl get nodes

Artık tüm ana düğümler iyi çalışıyor.

Kümeye çalışan nodeları ekleme

Tüm master nodeları başlattığınızda Kubernetes kümenize worker nodeları ekleyebilirsiniz. Ubuntu makinelerinde konuşlandırılan HA Kubernetes kümesine ilk çalışan düğümü (192.168.101.31) ekleyelim. Worker node’un kümeye katılmasını sağlamak için master nodeların başlatılmasından sonra görüntülenen komutu (belirteç ve karma içeren komut) kullanın. Komutu 192.168.101.31 makinesinde çalıştırın.

# kubeadm join 192.168.101.19:6443 –token kxl1gf.6ddalutd60n0ez45 \

–discovery-token-ca-cert-hash sha256:bf3887f1565fcd48ff696da98a761ac1b70c6d38ba0ba3e4b1bf573000a302ca

Worker node’un eklendiğinden emin olmak için Kubernetes HA kümesinin nodelarını kontrol edin. Artık node listesinde HA proxy makinesini de görebilirsiniz.

# kubectl get nodes

Benzer şekilde, Ubuntu makinelerinde kurulu olan Kubernetes Yüksek Erişilebilirlik kümesine diğer worker node’ları ekleyin. Taleplerinize bağlı olarak istediğiniz zaman daha fazla worker node ekleyebilirsiniz.

Yazının orijinalini buradan okuyabilirsiniz.

Hüseyin GÜÇ

Kariyerime 26 yıl önce başladım. Windows ve Linux sistemlerinin kurulumu, yapılandırılması, yönetimi ve bakımı dahil olmak üzere birden fazla sistem üzerinde uzmanlaştım.
Açık kaynak dünyasındaki en son gelişmelerden haberdar olmaktan ve Linux hakkındaki en son araçları, özellikleri ve hizmetleri denemekten hoşlanıyorum.
Son 6 yıldır  sistem ve ağ yöneticisi olarak görev yapıyorum ayrıca Pardus Dönüşüm Projesini yönetiyorum ve Pardus İşletim Sisteminin yaygınlaşması adına uğraş gösteriyorum.
Boş zamanlarımda açık kaynaklı uygulamaların Türkçe çevirisine katılıyorum ve The Document Foundation üyesiyim.