Jak zainstalować Kubernetes na Ubuntu
Ręczne wdrażanie kontenerów Docker na wielu serwerach może być bardzo czasochłonne i całkowicie zapełnić harmonogram pracy każdego administratora systemu, któremu powierzono to zadanie. We współczesnej branży IT popularność chmur, mikrousług i kontenerów stale rośnie, i właśnie z tego powodu opracowano rozwiązania takie jak Kubernetes.
Kubernetes to otwarte oprogramowanie do zarządzania kontenerami i orkiestracji, które pozwala na tworzenie klastrów ułatwiających wdrażanie kontenerów w środowiskach rozproszonych, a także zapewniających wysoką dostępność aplikacji kontenerowych. Celem tego wpisu na blogu jest omówienie sposobu instalacji Kubernetes na systemie Ubuntu w celu uruchamiania aplikacji w kontenerach Docker.
Wymagania i Konfiguracja Systemu do Instalacji Kubernetes na Ubuntu
Klaster Kubernetes składa się z węzłów master i węzłów roboczych. Konfiguracja sprzętowa zależy od Twoich potrzeb oraz aplikacji, które zamierzasz uruchomić w kontenerach Docker. Minimalne wymagania sprzętowe do instalacji Kubernetes na Ubuntu są następujące:
- Co najmniej 2-rdzeniowy procesor x86/x64
- 2 GB RAM (Pamięć Odruchowa) lub więcej
- Dostęp do internetu
Porty, które muszą być otwarte do instalacji Kubernetes na Ubuntu:
| Protokół i zakres portów | Źródło | Cel | Kierunek |
| TCP 443 | Węzły robocze, użytkownicy końcowi, żądania API | Serwer API Kubernetes | Węzeł master przychodzący |
| TCP 10250 | Węzły master | Port kontroli zdrowotnej Kubelet węzła roboczego | Węzeł roboczy przychodzący |
| TCP 30000-32767 | Zewnętrzni klienci aplikacji | Domyślny zakres portów do dostarczania usług zewnętrznych | |
| UDP 8285 | Węzły robocze | Tylne wsparcie UDP sieci nakładkowej Flannel | |
| UDP 8472 | Węzły robocze | Tylne wsparcie VXLAN sieci nakładkowej Flannel | |
| TCP 179 | Węzły robocze | Wymagany tylko, jeśli używana jest sieć Calico BGP | |
| TCP 2379-2380 | Węzły master | API klienta serwera etcd | Węzeł etcd przychodzący |
| TCP 2379-2380 | Węzły robocze | API klienta serwera etcd wymagany, jeśli używane są Flannel lub Calico |
Domyślnie, na Ubuntu zainstalowana jest zapora sieciowa iptables, lecz brak jest domyślnych reguł blokujących “out of the box”. Dlatego, jeśli instalujesz Ubuntu, aby wypróbować Kubernetes, nie musisz edytować reguł zapory. Kube-proxy umieszcza swoje łańcuchy iptables jako pierwsze, następnie dodaje dwie reguły iptables. Są to KUBE-EXTERNAL-SERVICES i KUBE-FIREWALL, które są obecne na początku łańcucha INPUT.
Instalacja Kubernetes na Ubuntu może być przeprowadzona zarówno na maszynach fizycznych, jak i wirtualnych. Ogólne zalecenie to użycie najnowszej wersji 64-bitowego Ubuntu Linux. W dzisiejszym wpisie na blogu wyjaśniono, jak zainstalować Kubernetes na systemie Ubuntu 18.04 LTS działającym na maszynach wirtualnych VMware. Pierwszy opisany typ wdrażania Kubernetes zakłada wykorzystanie jednego węzła głównego oraz dwóch węzłów roboczych w klastrze Kubernetes. W poniższej tabeli przedstawiono warunkową liczbę węzłów, role węzłów, nazwy hostów oraz adresy IP maszyn wykorzystanych w rozpatrywanym przykładzie.
| Nr | Rola węzła | Adres IP | Nazwa hosta |
| 1 | Główny | 192.168.101.21 | docker-nakivo21 |
| 2 | Roboczy | 192.168.101.31 | docker-nakivo31 |
| 3 | Roboczy | 192.168.101.32 | docker-nakivo32 |
Możesz korzystać z maszyn wirtualnych działających na hostach ESXi, jeśli używasz VMware vSphere, lub uruchamiać maszyny wirtualne w programie VMware Workstation zainstalowanym na komputerze osobistym z systemem Linux lub Windows. W dzisiejszym przykładzie korzystamy z maszyn wirtualnych działających na VMware Workstation. Maszyny wirtualne korzystają z sieci NAT sieć z dostępem do Internetu, a jeśli wolisz VirtualBox od VMware, możesz z niego skorzystać.
Adres IP komputera hosta: 10.10.10.53
Adres IP wirtualnej bramy dla sieci NAT (VMNet8): 192.168.101.2
Ten sam użytkownik systemu Linux istnieje na wszystkich maszynach z systemem Ubuntu: kubernetes-user
Konfiguracja maszyny wirtualnej: 2 procesory, 4 GB pamięci RAM, dysk wirtualny o pojemności 20 GB
Adresy IP sieci VMNet8 można zmienić, przechodząc do Edit > Virtual Network Editor w programie VMware Workstation.
Aby ułatwić zrozumienie, w dzisiejszym przykładzie wszystkie komponenty zostaną zainstalowane w systemie Linux ręcznie, bez użycia narzędzi do automatyzacji, takich jak Ansible.
Wdrażanie maszyny wirtualnej z systemem Ubuntu
Utwórz nową maszynę wirtualną o nazwie docker-nakivo21 .
Zainstaluj 64-bitową wersję systemu Ubuntu na pierwszej maszynie i ustaw nazwę hosta oraz nazwę użytkownika.
Nazwa maszyny wirtualnej: docker-nakivo21
Nazwa użytkownika: kubernetes-user
Zainstaluj VMware Tools po pierwszym zalogowaniu się do zainstalowanego systemu operacyjnego. Jeśli korzystasz z maszyn fizycznych, nie musisz używać VMware Tools i możesz pominąć ten krok.
Uwaga : Znak $ na początku oznacza, że polecenie jest uruchamiane jako zwykły użytkownik ( kubernetes-user w tym przypadku). Jeśli ciąg znaków zaczyna się od znaku #, polecenie musi zostać wykonane jako root . Polecenie sudo (zastąp użytkownika lub wykonaj jako superużytkownik) umożliwia wykonanie poleceń jako inny użytkownik w tym jako root. Możesz wpisać sudo -i aby uzyskać uprawnienia root w konsoli. Naciśnij Ctrl+D, aby wyjść z trybu root.
Możesz zainstalować Narzędzia VMware z obrazu ISO dostarczonego z hipernadzorcą VMware lub z repozytoriów Linux (wyjaśniono poniżej).
$ sudo apt-get install open-vm-tools
Jeśli potrzebujesz zaawansowanego doświadczenia w korzystaniu z pulpitu, takiego jak udostępniane schowki, przeciąganie i upuszczanie plików itp., uruchom:
$ sudo apt-get install open-vm-tools-desktop
Zrestartuj Maszynę wirtualną.
$ init 6
Skonfiguruj swój maszynę z Ubuntu przed instalacją Kubernetes
Pewne przygotowania muszą być podjęte przed zainstalowaniem Kubernetes na maszynach Ubuntu. Przede wszystkim, powinieneś skonfigurować statyczny Adres IP oraz nazwa hosta dla każdego zwykłego serwera.
Ustaw statyczny Adres IP
Jak w przypadku każdego innego typu klastra, zaleca się używanie statycznych adresów IP na węzłach.
Zainstaluj narzędzia sieciowe Linux przed ustawieniem Adres IP.
$ sudo apt-get install net-tools
Wpisz ifconfig , aby sprawdzić obecny Adres IP twojej maszyny Ubuntu.
Możesz zobaczyć, że Adres IP jest uzyskana automatycznie przez DHCP. Zapamiętaj nazwę interfejsu sieciowego. W obecnym przykładzie ta nazwa to ens33 . Nazwa pierwszego interfejsu sieciowego Ethernetu to zwykle eth0 dla maszyn fizycznych.
Potrzebujesz edytora tekstu do edytowania plików konfiguracyjnych. Zainstaluj vim jako edytor tekstu.
$ sudo apt-get install vim
W najnowszych wersjach Ubuntu, konfiguracja sieci jest ustawiona w pliku YAML. Otwórz plik konfiguracyjny sieciowy w vim.
$ sudo vim /etc/netplan/01-network-manager-all.yaml
Domyślny Widok pliku konfiguracyjnego jest:
Edytuj ten plik konfiguracyjny sieci w sposób pokazany poniżej:
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]
Zapisz zmiany i Wyjdź.
:wq
$ sudo netplan try
Naciśnij ENTER, aby zaakceptować nową konfigurację.
Sprawdź, czy twoja konfiguracja sieci została zmieniona i spróbuj pingować, na przykład, nakivo.com .
$ ifconfig
$ ping nakivo.com
Skonfiguruj nazwę hosta
Sprawdź swoją obecną nazwę hosta.
$ hostnamectl
Jak pamiętasz, nazwa hosta pierwszej maszyny wirtualnej, to docker-nakivo21 , została już skonfigurowana podczas instalacji. Aby zmienić nazwę hosta wykonaj poniższe kroki (będzie to potrzebne do skonfigurowania drugiej i trzeciej Maszyny wirtualnej po klonowaniu. Te dwie Maszyny wirtualne mają być skonfigurowane jako węzły robocze):
Na przykład, jeśli musisz zmienić nazwę hosta na docker-nakivo21 na pierwszej maszynie wirtualnej, uruchom: $ sudo hostnamectl set-hostname docker-nakivo21
Sprawdź, czy nowa nazwa hosta została zastosowana.
$ less /etc/hostname
Edytuj plik hosts .
$ sudo vim /etc/hosts
Zawartość pliku hosts musi wyglądać następująco:
127.0.0.1 localhost
127.0.1.1 docker-nakivo21
Uruchom ponownie maszynę.
$ init 6
Wyłącz plik wymiany
Korzystanie z plików wymiany (partycji swap) nie jest obsługiwane przez Kubernetes, a wyłączenie swappiness jest konieczne do pomyślnej instalacji Kubernetes na Ubuntu.
Wyłącz plik wymiany, aby zapobiec wysokiemu zużyciu procesora przez kubelet.
$ sudo swapoff -a
Edytuj /etc/fstab i skomentuj ciąg znaków za pomocą znaku # .
$ sudo vim /etc/fstab
#/swapfile none swap sw 0 0
To samo można zrobić za pomocą sed za pomocą jednego polecenia:
$ sudo sed -i '/ swap / s/^(.*)$/#1/g' /etc/fstab
Wyłącz swap w sysctl.conf
$ sudo echo "vm.swappiness=0" | sudo tee --append /etc/sysctl.conf
Gdzie 0 to procent swapiness. W tym przypadku swap może być używany tylko wtedy, gdy zabraknie pamięci RAM (domyślnie swap jest używany, gdy ponad 60% pamięci RAM jest zapełnione).
Zastosuj zmiany konfiguracji bez ponownego uruchamiania.
$ sudo sysctl -p
Uwaga : Jeśli partycja swap nie jest wyłączona, proces kswapd0 w systemie Ubuntu Linux z uruchomionym Kubernetesem może zużywać dużą ilość zasobów procesora na komputerze, powodując, że aplikacje przestają odpowiadać, a system zawiesza się. Dzieje się tak, gdy systemowi operacyjnemu zabraknie pamięci, a stare strony pamięci są przenoszone do partycji swap przez proces systemowy jądra Linuxa. Z nieznanych przyczyn czasami dochodzi do nieprawidłowości i powstaje niekończąca się pętla, która zużywa wszystkie zasoby procesora. Na poniższym zrzucie ekranu widać wysokie zużycie procesora przez proces kswapd0 po zainstalowaniu Kubernetes na systemie Ubuntu. Średnia wartość obciążenia jest nadmiernie wysoka.
Jeśli procesy kswapd0 nadal przeciążają Procesor, uruchom następujące polecenie, aby wyczyścić wszystkie pamięci podręczne i zatrzymać procesy kswapd0 (wykonaj jako root).
# echo 1 > /proc/sys/vm/drop_caches
Wyłącz maszynę wirtualną.
$ init 0
Ta częściowo skonfigurowana maszyna wirtualna ( docker-nakivo21 ) ma zostać wykorzystana jako węzeł główny. Utwórz dwie maszyny, które posłużą jako węzły robocze. Jeśli korzystasz z maszyn fizycznych, powtórz poprzednie kroki ręcznie (lub użyj narzędzi do automatyzacji, takich jak Ansible, do jednoczesnej konfiguracji wielu maszyn z systemem Linux przez SSH). Ponieważ w obecnym przykładzie używane są maszyny wirtualne, można je sklonować, aby zaoszczędzić czas podczas przygotowywania środowiska do instalacji Kubernetes na maszynach z systemem Ubuntu.
Sklonuj maszynę wirtualną
Sklonuj swoją pierwszą maszynę wirtualną. Jeśli korzystasz z VMware ESXi, możesz użyć wbudowanej funkcji klonowania. Możesz dowiedzieć się więcej na ten temat, czytając nasz wpis na blogu w sekcji klonowanie maszyn wirtualnych przy użyciu szablonów maszyn wirtualnych. Jeśli korzystasz ze stacji roboczej VMware, możesz również klonować maszyny wirtualne używając dwóch metod (wbudowane narzędzie do klonowania oraz ręcznie). Możesz kliknąć VM > Manage > Clone, aby utworzyć powiązany klon. Utwórzmy pełny klon pierwszej maszyny wirtualnej i ręcznie skopiujmy pliki maszyny wirtualnej. W tym przypadku pliki są kopiowane z katalogu docker-nakivo21 do docker-nakivo31. Katalogi muszą być utworzone ręcznie przed skopiowaniem plików maszyny wirtualnej.
Edytuj plik VMX, ponieważ nazwa maszyny wirtualnej i ścieżka do pliku dysku wirtualnego zostały zmienione.
displayName = "docker-nakivo31"
scsi0:0.fileName = "C:VirtualKUBERNETESdocker-nakivo31docker-nakivo31.vmdk"
nvram = "docker-nakivo31.nvram"
Maszyna wirtualna, która będzie używana jako pierwszy węzeł roboczy, została już utworzona. Sklonuj po raz kolejny pierwszą maszynę wirtualną, aby przygotować drugi węzeł roboczy klastra Kubernetes.
Edytuj plik VMX dla trzeciej maszyny wirtualnej (drugiego węzła roboczego), jak zrobiono wcześniej.
displayName = "docker-nakivo32"
scsi0:0.fileName = "C:VirtualKUBERNETESdocker-nakivo31docker-nakivo32.vmdk"
nvram = "docker-nakivo32.nvram"
Otwórz klony maszyn wirtualnych w stacji roboczej VMware (File> Open i wybierz plik VMX maszyny wirtualnej), lub po prostu dwukrotnie kliknij plik VMX maszyny wirtualnej. Włącz trzy maszyny wirtualne (swoją jedną maszynę źródłową i dwa klony maszyn wirtualnych). Kliknij Skopiowałem to , gdy pojawi się komunikat.
Uwaga : Jeśli korzystasz z maszyn wirtualnych, zmień adres IP i nazwę hosta na każdej maszynie-klonie po sklonowaniu maszyn wirtualnych. Jeśli korzystasz z maszyn fizycznych, postępuj zgodnie z wcześniejszymi krokami zgodnie z adresami IP i nazwami hostów dla każdej maszyny.
Konfiguracja adresów IP i nazw hostów na maszynach wirtualnych
Zmień adres IP i nazwę hosta na docker-nakivo31 i docker-nakivo32 maszyn wirtualnych (jak pokazano powyżej).
Powtórz kroki opisane w powyższych sekcjach, aby skonfigurować statyczne adresy IP i nazwy hostów.
Adres IP musi być: 192.168.101.31 i 192.168.101.32 ; nazwy hostów muszą być docker-nakivo31 i docker-nakivo32 odpowiednio na węzłach roboczych.
Wszystkie maszyny muszą być skonfigurowane do rozwiązywania nazw hostów węzłów do adresów IP. Możesz skonfigurować serwer DNS lub ręcznie edytować plik hosts na każdej maszynie. Edytujmy hosts .
Dodaj następujące ciągi do pliku hosts na każdej maszynie ( docker-nakivo21 , docker-nakivo31 , docker-nakivo32 ).
$ sudo vim /etc/hosts
Dodaj te linie do pliku hosts :
192.168.101.21 docker-nakivo21
192.168.101.31 docker-nakivo31
192.168.101.32 docker-nakivo32
Pinguj inne hosty z każdego hosta, aby upewnić się, że nazwy hostów są rozwiązywane: $ ping docker-nakivo21
$ ping docker-nakivo31
$ ping docker-nakivo32
Konfiguracja dostępu SSH na wszystkich hostach (maszynach wirtualnych)
Skonfiguruj dostęp SSH na wszystkich hostach. Zainstaluj serwer OpenSSH, wykonując polecenia na każdej maszynie.
$ sudo apt-get install openssh-server
Przejdź do katalogu domowego użytkownika kubernetes i wygeneruj parę kluczy SSH (zestaw kluczy kryptograficznych składający się z klucza prywatnego i klucza publicznego). Pary kluczy SSH mogą być wykorzystywane do uzyskiwania dostępu do zdalnej konsoli systemu Linux za pośrednictwem protokołu SSH bez konieczności podawania hasła. Klucz publiczny można skopiować na komputer, z którego ma nastąpić zdalne połączenie, natomiast klucz prywatny jest ściśle tajny i musi być przechowywany na komputerze, z którym ma nastąpić połączenie.
$ ssh-keygen
Podczas generowania kluczy nie ma konieczności wprowadzania hasła (hasło jest opcjonalne).
Skopiuj klucze na inne maszyny z systemem Ubuntu:
$ ssh-copy-id kubernetes-user@192.168.101.31
$ ssh-copy-id kubernetes-user@192.168.101.32
Wprowadź hasło użytkownika, aby potwierdzić skopiowanie kluczy.
Spróbuj połączyć się z drugą maszyną ( docker-nakivo31 ) jako kubernetes-user (czyli zwykły użytkownik).
$ ssh 'kubernetes-user@192.168.101.31'
Następnie sprawdź połączenie z trzecią maszyną ( docker-nakivo32 ).
$ ssh 'kubernetes-user@192.168.101.32'
Po pomyślnym nawiązaniu połączenia w wierszu poleceń konsoli pojawi się nazwa zdalnej maszyny.
Naciśnij Ctrl+D, aby wyjść ze zdalnej konsoli.
Jak skopiować klucz do łączenia się przez SSH jako użytkownik główny?
Ponieważ w Kubernetes będziesz potrzebować uprawnień użytkownika głównego, utwórzmy klucze do skonfigurowania dostępu SSH dla użytkownika głównego. Wykonaj następujące polecenia na wszystkich maszynach (docker-nakivo21, docker-nakivo31 i docker-nakivo32), do których dostęp przez SSH jako użytkownik główny jest wymagany.
$ sudo -i
Edytuj plik konfiguracyjny serwera SSH.
# vim /etc/ssh/sshd_config
Dodaj/edytuj następujący ciąg znaków w tym pliku.
PermitRootLogin yes
Uruchom ponownie demona serwera SSH.
# /etc/init.d/ssh stop
# /etc/init.d/ssh start
Ustaw hasło użytkownika głównego (hasło dla użytkownika głównego).
# passwd
$ cd /home/kubernetes-user/
$ sudo ssh-keygen -t rsa
Skopiuj klucz publiczny, aby móc zalogować się zdalnie przez SSH jako użytkownik główny (klucz jest przechowywany w katalogu domowym zwykłego użytkownika, ponieważ poprzednie polecenie zostało uruchomione z tego katalogu).
$ sudo ssh-copy-id -i /home/kubernetes-user/.ssh/id_rsa.pub 127.0.0.1
Jeśli klucz jest zapisany w katalogu domowym użytkownika głównego, skopiuj go za pomocą tego polecenia:
# ssh-copy-id -i /root/.ssh/id_rsa.pub 127.0.0.1
Potwierdź tę operację i wprowadź hasło.
Powtórz tę czynność, kopiując klucz z każdej maszyny na pozostałe. Na przykład na maszynie docker-nakivo21 wykonaj:
# 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
Autoryzuj klucz publiczny.
# cat /root/.ssh/id_rsa.pub >> /root/.ssh/authorized_keys
Sprawdź, czy możesz zalogować się jako użytkownik główny przez SSH na maszynie lokalnej. $ sudo ssh root@127.0.0.1
Spróbuj połączyć się ze zdalnym użytkownikiem, nie wprowadzając hasła.
$ sudo ssh root@192.168.101.21
$ sudo ssh root@192.168.101.31
$ sudo ssh root@192.168.101.32
Uwaga : Łączenie się jako użytkownik główny może być niebezpieczne. Nie łącz się jako użytkownik główny, jeśli nie jest to konieczne — lepiej połączyć się przez SSH jako zwykły użytkownik i użyć polecenia sudo.
Instalacja Dockera
Docker to najpopularniejsza platforma kontenerów aplikacyjnych dla przedsiębiorstw wspierana przez Kubernetes. Zainstaluj Dockera na wszystkich maszynach. Wykonaj polecenia pokazane poniżej na docker-nakivo21 , docker-nakivo31 , docker-nakivo32 .
Mimo to, nie ma potrzeby się spieszyć. Na pierwszy rzut oka można po prostu zainstalować Dockera, używając zwykłego polecenia:
$ sudo apt-get install -y docker.io
Jednak w tym przypadku użyta wersja Dockera może nie być najnowszą. Poprawmy to, instalując najnowszą wersję Dockera.
Najpierw zainstaluj wymagane pakiety.
$ sudo apt-get install apt-transport-https ca-certificates curl software-properties-common
Curl to uniwersalne kompaktowe narzędzie przeznaczone do przesyłania danych do i z hosta bez interakcji użytkownika z użyciem jednego z obsługiwanych protokołów (HTTP, HTTPS, FTP, FTPS, SFTP, LDAP, LDAPS, IMAP, IMAPS, POP3, POP3S, SCP, SMB, SMTP, TELNET itp.).
Dodaj klucz GPG oficjalnego repozytorium Dockera do swojego systemu Ubuntu:
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
Wyjście konsoli powinno być OK.
Dodaj oficjalne repozytorium Dockera do menedżera pakietów apt:
$ sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu bionic stable"
Zaktualizuj bazę danych menedżera pakietów po ręcznych zmianach dokonanych przez poprzednie polecenie.
$ sudo apt-get update
Sprawdź wersję pakietu Docker dostępnego w oficjalnym repozytorium.
$ apt-cache policy docker-ce
Zainstaluj Dockera.
$ sudo apt-get install docker-ce
Możesz sprawdzić wersję Dockera po instalacji.
$ docker --version
W tym przypadku wyjście to: Wersja Dockera 18.09.6, kompilacja 481bc77 .
Uruchom Dockera i ustaw, aby jego demon był ładowany automatycznie przy starcie systemu.
$ sudo systemctl start docker
$ sudo systemctl enable docker
Kiedy zainstalujesz Dockera na wszystkich maszynach, możesz przejść bezpośrednio do kroku instalacji Kubernetesa na Ubuntu.
Instalacja Kubernetesa na Ubuntu i inicjalizacja klastra
Teraz nic nie stoi na przeszkodzie, by zainstalować podstawowe komponenty Kubernetesa.
Wykonaj polecenia jako użytkownik główny na wszystkich maszynach, które mają być włączone do klastra Kubernetesa.
$ sudo -i
Dodaj klucz GPG oficjalnego repozytorium Dockera do swojego systemu Ubuntu:
# curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -
Dodaj oficjalne repozytorium Kubernetesa do bazy dostępnych repozytoriów pakietów dla swojego menedżera pakietów apt.
# cat <<EOF >/etc/apt/sources.list.d/kubernetes.list
deb http://apt.kubernetes.io/ kubernetes-xenial main
EOF
Alternatywnie, możesz dodać repozytorium tym poleceniem: # echo 'deb http://apt.kubernetes.io/ kubernetes-xenial main' | sudo tee /etc/apt/sources.list.d/kubernetes.list
Gdzie tee jest narzędziem, które odczytuje dane wejściowe standardu i zapisuje dane wejściowe do standardowego wyjścia i zdefiniowanych plików.
Aktualizuj listę pakietów dostępnych repozytoriów na swoim systemie Ubuntu.
# apt-get update
Instalacja kubectl , kubeadm oraz kubectl jest kluczowa do zainstalowania Kubernetes na Ubuntu.
# apt-get install -y kubelet kubeadm kubectl
Zainstaluj keepalived.
# apt-get install keepalived
# systemctl enable keepalived && systemctl start keepalived
Weryfikuj czy wartość jest 1 dla prawidłowego działania Kubernetes zainstalowanego na Ubuntu.
# sysctl net.bridge.bridge-nf-call-iptables
Aby ustawić tę wartość na 1 uruchom polecenie:
sysctl net.bridge.bridge-nf-call-iptables=1
Edytuj plik konfiguracji kubeadm.
# vim /etc/systemd/system/kubelet.service.d/10-kubeadm.conf
Dodaj ciąg po istniejącym ciągu Environment:
Environment=”cgroup-driver=systemd/cgroup-driver=cgroupfs”
Cgroups są grupami kontrolnymi, które izolują wykorzystanie zasobów takich jak procesor, pamięć, dysk wejście/wyjście, sieć.
Na węźle głównym ( docker-nakivo21 ) uruchom polecenie, aby zainicjalizować klaster Kubernetes na Ubuntu.
# kubeadm init --pod-network-cidr=10.244.0.0/16 --apiserver-advertise-address=192.168.101.21
Gdzie
–pod-network-cidr jest wymagany przez sterownik Flannel. CIDR (Classless Inter-Domain Routing) definiuje adres sieci nakładkowej (takiej jak Flannel), która zostanie skonfigurowana później. Maska sieciowa definiuje również, ile podów może być uruchomionych na węzeł. Adres sieci CIDR i adres sieci używane dla Flannel muszą być takie same.
–apiserver-advertise-address=192.168.101.21 definiuje adres IP, który będzie reklamowany przez Kubernetes jako jego serwer API.
Przeczytaj wyjście i zapisz polecenia wyświetlane na końcu tekstu. To jest ważny punkt. Wygenerowany token jest wymagany do dodania węzłów roboczych do klastra Kubernetes.
Uruchom poniższe polecenia jako użytkownik, który uruchomił kubeadm init. W tym przypadku, polecenia są wykonywane jako root.
# mkdir -p $HOME/.kube
# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
# sudo chown $(id -u):$(id -g) $HOME/.kube/config
Jeżeli nie uruchomisz tych poleceń, Kubernetes zwróci błąd: Połączenie z serwerem localhost:8080 zostało odrzucone – czy podałeś poprawny host lub port?
Kubernetes nie kopiuje automatycznie tego pliku konfig do katalogu użytkownika. Musisz wykonać tę operację ręcznie.
Sprawdź węzły dodane do klastra
# kubectl get nodes
Możesz zobaczyć jeden węzeł główny, który ma status NotReady w klastrze Kubernetes, który jest instalowany na Ubuntu. Wynika to z faktu, iż sieć nakładkowa nie została skonfigurowana. Skonfiguruj Flannel, aby naprawić status NotReady węzła głównego Kubernetes. Utwórz katalog do przechowywania plików yaml dla Docker i Kunernetes, na przykład /home/kubernetes-user/kubernetes/
YAML (skrót od Yet Another Markup Language) oferuje większą wygodę przy tworzeniu podów i wdrożeń w Kubernetes. Możesz zdefiniować wszystkie parametry kontenerów, które muszą zostać wdrożone, w konfiguracji YAML zamiast uruchamiać każde polecenie ręcznie w konsoli Linux. Pliki YAML w kontekście Kubernetes nazywane są także plikami manifestów.
Utwórz plik konfiguracyjny yaml o następującej treści:
Uruchom polecenie
# kubectl apply -f ./kube-flannel.yml
Alternatywnie, możesz znaleźć gotowe darmowe przykłady konfiguracji wdrożeniowej YAML dla Kubernetes na GitHub.
kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/a70459be0084506e4ec919aa1c114638878db11b/Documentation/kube-flannel.yml
Sprawdź węzły dodane do klastra Kubernetes, który wdrażasz na Ubuntu:
# kubectl get nodes
Status węzła master teraz to Gotowy.
Upewnij się, że Flannel został poprawnie ustawiony:
# kubectl get pods --all-namespaces
Widać, że pod Flannel działa. Ten pod składa się z dwóch kontenerów – demona Flannel i initContainer używanego do wdrożenia konfiguracji CNI w lokalizacji dostępnej dla Kubernetes.
Czasami, gdy instalujesz Kubernetes na Ubuntu, może wystąpić następujący błąd:
Nie można połączyć się z serwerem: net/http: Czas oczekiwania na połączenie TLS upłynął.
Jak rozwiązać ten problem? Poczekaj kilka sekund i spróbuj ponownie — to często wystarcza.
Przestrzenie nazw są logicznymi jednostkami w klastrze Kubernetes, które reprezentują zasoby klastra i można je uznać za wirtualne klastry. Jeden fizyczny klaster można logicznie podzielić na wiele wirtualnych klastrów. Domyślne przestrzenie nazw Kubernetes to Domyślne , Kube-public , oraz Kube-system . Możesz uzyskać listę przestrzeni nazw:
# kubectl get namespaces
Jak pamiętasz, podstawową jednostką wdrożenia w Kubernetes jest pod, który jest zbiorem kontenerów współdzielących sieć i przestrzeń montowania nazwy. Wszystkie kontenery wchodzące w skład poda są zaplanowane na tym samym węźle Kubernetes. Sprawdź dostępne pody:
# kubectl -n kube-system get pods
Jeśli chcesz zresetować/zatrzymać klaster, uruchom:
# kubeadm reset
Na węźle master wszystko jest OK. Oznacza to, że teraz możesz kontynuować instalację Kubernetes na Ubuntu i przejść do dodawania węzłów roboczych do klastra.
Na węzłach roboczych ( docker-nakivo31 , docker-nakivo32 ) uruchom polecenie:
# kubeadm join 192.168.101.21:6443 --token d8mbzb.uulxu01jbty8yh4z
--discovery-token-ca-cert-hash sha256:65ace7a4ff6fff795abf086f18d5f0d97da71d4639a0d0a6b93f42bea4948a79
Token i hash zostały odnotowane po zainicjowaniu klastra z poleceniem kubeadm init, jak może pamiętasz.
Na węźle master ponownie sprawdź status klastra. # kubectl get nodes
Teraz możesz zobaczyć jeden główny węzeł i dwa pracujące węzły w klastrze Kubernetes działającym na maszynach Ubuntu.
Możesz sprawdzić konfigurację Kubernetes:
# kubectl cluster-info
Wdrażanie Podu w Kubernetes
Teraz możesz wdrożyć pod z kontenerami w swoim klastrze Kubernetes. Jak pamiętasz, kontenery są zawarte w podach w Kubernetes. Jeśli używasz plików yaml, stwórz katalog do przechowywania tych plików dla większej wygody. Przejdź do tego katalogu i uruchom polecenia takie jak kubectl apply -f test.yaml
Taki katalog został już utworzony podczas konfigurowania Flannel – /home/kubernetes-user/kubernetes/
Nadszedł czas na wdrożenie nowego podu. Najpierw musisz stworzyć wdrażanie. Wdrażanie to pojęcie kontrolera używane do zapewnienia deklaratywnych aktualizacji dla podów i zestawów replik. Możesz stworzyć wdrażanie za pomocą jednego polecenia lub korzystając z plików yaml.
Przykład 1 – wdrażanie MySQL
Stwórzmy plik yaml w tym przykładzie. Nazwa pliku to mysql-deployment.yaml
Zobacz załączony plik, aby zobaczyć konfigurację.
# vim mysql-deployment.yaml
Istnieją dwa popularne podejścia do zarządzania zasobami z użyciem kubectl . Jaka jest różnica między kubectl create i kubectl apply ? Korzystając z kubectl create , informujesz Kubernetes, co chcesz utworzyć, zastąpić lub usunąć; to polecenie nadpisuje wszystkie zmiany. Alternatywnie, kubectl apply dokonuje przyrostowych zmian i to polecenie może być używane do zapisywania zmian zastosowanych do żywego obiektu.
Stwórz wdrażanie:
# kubectl apply -f ./mysql-deployment.yaml
Kubernetes może wyświetlać informacje o twoim wdrażaniu.
# kubectl describe deployment mysql
Sprawdź leby:
# kubectl get po
lub
# kubectl get pods
lub
# kubectl get pods -l app=mysql
Jeśli zobaczysz status oczekiwania dla podu, może to oznaczać, że nie ma wystarczających zasobów obliczeniowych. Spróbuj dodać trochę pojemności CPU i pamięci, aby naprawić status oczekiwania podu w Kubernetes.
Możesz usunąć serwis, jeśli to konieczne:
# kubectl delete service <service_name>
Możesz również usunąć pod:
# kubectl delete pod mysql-7b9b7999d8-nz5tm
Przykład 2 – Wdrażanie nginx
Wdróźmy nginx korzystając z innej metody bez plików yaml.
Stwórz wdrażanie.
# kubectl create deployment nginx --image=nginx
Sprawdź, czy wdrażanie zostało utworzone.
# kubectl get deployments
Stwórz serwis.
# kubectl create service nodeport nginx --tcp=80:80
Serwis można stworzyć, używając następujących typów serwisów – ClusterIP, NodePort, LoadBalance i ExternalName. Jeśli używany jest typ NodePort, wówczas losowy port z zakresu 30000-32767 jest przydzielany do dostępu do oferowanych usług. Ruch, który jest wysyłany do tego portu, jest przesyłany do niezbędnej usługi.
Sprawdź, czy usługa została utworzona i nasłuchuje na zdefiniowanym porcie.
# kubectl get svc
Zapamiętaj numer portu (w tym przypadku 31453).
Sprawdź, czy Twoja usługa została wdrożona i jest dostępna (polecenie jest wykonywane na węźle głównym w tym przykładzie). Użyj nazwy hosta węzła oraz numeru portu, który zapamiętałeś z poprzedniego kroku.
# curl docker-nakivo31:31453
Możesz także sprawdzić, czy usługa jest dostępna w przeglądarce dowolnego węzła. W pasku adresu przeglądarki spróbuj odwiedzić strony:
http:// 10.101.235.90
lub
http://docker-nakivo31:31453
http://docker-nakivo32:31453
Jeśli wszystko jest w porządku, zobaczysz stronę powitalną nginx.
Możliwe jest również odwiedzenie strony testowej nginx z dowolnej maszyny, która ma dostęp do sieci, do której są podłączone węzły Kubernetes—( 192.168.101.0/24 ) w tym przypadku. Na przykład, możesz odwiedzić strony internetowe w przeglądarce:
http://192.168.101.21:31453/
http://192.168.101.31:31453/
http://192.168.101.32:31453/
Skonfiguruj interfejs webowy do monitorowania Kubernetes
Instalacja Kubernetes na Ubuntu jest prawie zakończona, ale możesz również zainstalować pulpit Kubernetes dla większej wygody. Pulpit Kubernetes to webowy interfejs do zarządzania i monitorowania Kubernetes. Aby zainstalować pulpit, utwórz plik kubernetes-dashboard.yaml , tak jak wcześniej przed wykonaniem poleceń.
# kubectl create -f ./kubernetes-dashboard.yaml
# kubectl apply -f ./kubernetes-dashboard.yaml
Sprawdź podłączenia.
# kubectl get pods -o wide --all-namespaces
Uruchom proxy do serwera API Kubernetes.
# kubectl proxy
Aby wprowadzić następne polecenia w konsoli, otwórz nowe okno konsoli. W przeciwnym razie proces zostanie zakończony.
W swojej przeglądarce internetowej na węźle głównym przejdź na stronę:
http://localhost:8001
Możesz zobaczyć stronę testową.
Wprowadź pełny adres w pasku adresu przeglądarki.
http://localhost:8001/api/v1/namespaces/kube-system/services/https:kubernetes-dashboard:/proxy/
Utwórz pulpit z kontem serwisowym, wykonując polecenia w nowym oknie konsoli.
# 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
Teraz możesz zobaczyć wygenerowany token:
Skopiuj wygenerowany token i wklej go w sekcji tokenów interfejsu webowego, aby zalogować się do pulpitu.
Na poniższym zrzucie ekranu możesz zobaczyć interfejs webowy pulpitu Kubernetes. Możesz zobaczyć status węzłów, wdrożeń i pod, a także sprawdzić role, klasy magazynowe i inne komponenty. 
Ustawienie Heapstera jako narzędzie do monitorowania
.
Zainstaluj Heapstera, aby rozszerzyć opcje monitorowania w panelu Kubernetes poprzez dodanie parametrów monitorowania procesora, pamięci i innych czynników. Utwórz plik manifestu o nazwie heapster.yaml .
# vim heapster.yaml
W następnym kroku wdrażaj Heapstera.
# kubectl create -f heapster.yaml
Edytuj rolę RBAC (kontrola dostępu oparta na rolach) dla Heapstera i dodaj uprawnienia do uzyskiwania dostępu do statystyk węzłów.
# kubectl edit clusterrole system:heapster
Sprawdź, czy można mierzyć procesor oraz parametrów pamięci w konsoli.
# kubectl top node
Teraz możesz otworzyć interfejs internetowy panelu Kubernetes i zobaczyć, że dodano niektóre sekcje, w tym wykresy użycia procesora i pamięci.
Twój klaster Kubernetes jest teraz skonfigurowany i gotowy do pracy.
Wdrażanie klastra Kubernetes o wysokiej dostępności z wieloma węzłami na Ubuntu
Posiadanie klastra Kubernetes z jednym węzłem głównym i kilkoma węzłami pracowniczymi to dobra opcja, ale czasami jedyny węzeł główny może ulec awarii z powodów takich jak problemy sprzętowe lub brak zasilania. Dla większej odporności na awarie klastra Kubernetes wdrożonego na węzłach Ubuntu lepiej jest rozważyć wdrożenie klastra Kubernetes o wysokiej dostępności z wieloma węzłami głównymi. Korzystanie z tego modelu wdrożenia klastra Kubernetes pozwala uniknąć pojedynczego punktu awarii. Zaleca się korzystanie z nieparzystej liczby węzłów głównych, a minimalna liczba węzłów głównych, która zapewnia odporność na awarie, to trzy. Gdy używasz więcej niż trzech węzłów głównych i liczba węzłów jest parzysta, odporność na awarie całego klastra się nie zwiększa. Zobacz poniższą tabelę, aby porównać wartość odporności na awarie w zależności od liczby węzłów głównych w klastrze Kubernetes. Na przykład, jeśli masz klaster z 5 węzłami głównymi, klaster może przetrwać awarię 2 węzłów głównych, ponieważ trzy węzły główne nadal działają (3 z 5 to więcej niż 50% i tworzy większość). Rozmiar klastra odnosi się do liczby węzłów głównych w klastrze.
| Rozmiar klastra | Większość | Odporność na awarie |
| 1 | 1 | 0 |
| 2 | 2 | 0 |
| 3 | 2 | 1 |
| 4 | 3 | 1 |
| 5 | 3 | 2 |
| 6 | 4 | 2 |
| 7 | 4 | 3 |
| 8 | 5 | 3 |
| 9 | 5 | 4 |
W tej części dzisiejszego wpisu na blogu omówiono sposób instalacji Kubernetes na węzłach z systemem Ubuntu w ramach wdrażania klastra Kubernetes o wysokiej dostępności (HA), serwera proxy HA oraz kilku węzłów roboczych. W poniższej tabeli przedstawiono adresy IP, nazwy hostów oraz role hostów wykorzystywanych do instalacji klastra Kubernetes o wysokiej dostępności (HA) na węzłach Ubuntu w laboratorium testowym opisanym w tym przykładzie.
| Nr | Rola węzła | Adres IP | Nazwa hosta |
| 1 | Master | 192.168.101.21 | docker-nakivo21 |
| 2 | Master | 192.168.101.22 | docker-nakivo22 |
| 3 | Master | 192.168.101.23 | docker-nakivo23 |
| 4 | HA Proxy | 192.168.101.19 | ha-proxy19 |
| 5 | Worker | 192.168.101.31 | docker-nakivo31 |
| 6 | Worker | 192.168.101.32 | docker-nakivo32 |
Niektóre polecenia są takie same jak podczas instalacji Kubernetes na Ubuntu przy użyciu modelu z jednym węzłem głównym. Z tego powodu komentarze do niektórych poleceń nie są powtarzane. Możesz przewinąć tę stronę w górę, aby przypomnieć sobie objaśnienia poleceń.
Przygotuj wszystkie maszyny (proxy HA, węzły główne i węzły robocze) do instalacji Kubernetes, wykonując następujące czynności:
- Skonfiguruj statyczne adresy IP.
- Ustaw nazwy hostów. Nazwy wszystkich hostów muszą być rozpoznawane jako adresy IP.
- Dostęp SSH musi być włączony i skonfigurowany przy użyciu certyfikatów.
- Pamięć wymiany (swap) musi być wyłączona.
Kroki te należy wykonać przed rozpoczęciem instalacji Docker na każdym komputerze, podobnie jak opisano w powyższej sekcji, w której wyjaśniono instalację Kubernetes na systemie Ubuntu przy użyciu jednego węzła głównego. Po przygotowaniu wszystkich maszyn przejdź do ( 192.168.101.19 ).
Konfiguracja moduł równoważenia obciążenia HA Proxy
Moduł równoważenia obciążenia HA Proxy służy do rozdzielania ruchu przychodzącego między węzłami Kubernetes. Moduł ten jest wdrażany przed węzłami głównymi. Otwórz konsolę maszyny ha-proxy19 i wykonaj poniższe działania.
Zainstaluj cfssl
Cfssl (Cloud Flare SSL) to zestaw narzędzi używany do generowania różnych certyfikatów, w tym łańcuchów certyfikatów TLS/SSL.
Pobierz binaria z oficjalnego repozytorium.
# wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64
# wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64
Uczyń pobrane pliki binarne możliwymi do uruchomienia.
# chmod +x cfssl*
Przenieś te pliki binarne do /usr/local/bin/
# mv cfssl_linux-amd64 /usr/local/bin/cfssl
# mv cfssljson_linux-amd64 /usr/local/bin/cfssljson
Zweryfikuj instalację, sprawdzając wersję zainstalowanego cfssl.
# cfssl version
Aktualizuj drzewo repozytoriów.
# apt-get update
Zainstaluj HA proxy.
# apt-get install haproxy
Utwórz i edytuj plik haproxy.cfg .
# vim /etc/haproxy/haproxy.cfg
Dodaj te linie na końcu tego pliku konfiguracyjnego.
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
Uruchom ponownie usługę.
# systemctl restart haproxy
Generuj certyfikaty TSL
Możesz kontynuować korzystanie z konsoli maszyny HA proxy. Utwórz plik konfiguracyjny urzędu certyfikacji, który nazywa się ca-config.json .
# vim ca-config.json
Dodaj następującą zawartość do tego pliku konfiguracyjnego:
{
"signing": {
"default": {
"expiry": "8760h"
},
"profiles": {
"kubernetes": {
"usages": ["signing", "key encipherment", "server auth", "client auth"],
"expiry": "8760h"
}
}
}
}
Utwórz plik konfiguracyjny żądania podpisania certyfikatu urzędu certyfikacji.
# vim ca-csr.json
Dodaj zawartość do tego pliku w sposób pokazany poniżej:
{
„CN”: „Kubernetes”,
„key”: {
„algo”: „rsa”,
„size”: 2048
},
„names”: [
{
„C”: „GB”,
„L”: „London”,
„O”: „Kubernetes”,
„OU”: „CA”,
„ST”: „Nakivo”
}
]
}
Gdzie:
C – kraj, na przykład GB (Wielka Brytania).
L – lokalizacja, taka jak miasto lub wieś.
O – organizacja.
OU – jednostka organizacyjna (na przykład dział zdefiniowany jako właściciel klucza).
ST – stan lub prowincja.
Teraz wygeneruj klucz i klucz prywatny.
# cfssl gencert -initca ca-csr.json | cfssljson -bare ca
Zweryfikuj, że klucze ca-key.pem i ca.pem zostały wygenerowane.
# ls -al
Tworzenie certyfikatu dla klastra Etcd
Etcd wspiera komunikację serwer-serwer/klaster poprzez uwierzytelnianie za pomocą certyfikatów klienta. Powinieneś mieć certyfikat urzędu certyfikacji oraz parę podpisanych kluczy dla jednego uczestnika klastra.
Utwórz plik konfiguracyjny żądania podpisania certyfikatu.
# vim kubernetes-csr.json
{
"CN": "kubernetes",
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "GB",
"L": "London",
"O": "Kubernetes",
"OU": "Kubernetes",
"ST": "Nakivo"
}
]
}
Następnie wygeneruj certyfikat i klucz prywatny.
# 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
Wymień pliki w swoim katalogu, aby zweryfikować, że pliki kubernetes-key.pem i kubernetes.pem zostały wygenerowane.
# ls -al
Skopiuj utworzony certyfikat do każdego węzła. # scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.21:~
# scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.22:~
# scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.23:~
# scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.31:~
# scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.32:~
# scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.33:~
Gdzie ~ to katalog domowy użytkownika kubernetes na hostach Ubuntu.
Przygotowanie węzłów Ubuntu do instalacji Kubernetes
Uruchom polecenia pokazane w tej sekcji na wszystkich węzłach master i węzłach roboczych. Zainstaluj Dockera, a następnie zainstaluj Kubernetes na maszynach Ubuntu, które będą włączone do klastra Kubernetes. Zaczniemy od przygotowania węzła master 192.168.101.21 .
Zainstaluj Dockera.
# 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 jest teraz zainstalowany. Kubeadm, kublet i kubectl to komponenty Kubernetes wymagane do zainstalowania Kubernetes na Ubuntu.
Zainstaluj komponenty Kubernetes – kubeadm, kublet i kubectl.
# 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
Po przygotowaniu wszystkich węzłów i zainstalowaniu Dockera, kubelet, kubeadm i kubectl, musisz zainstalować i skonfigurować etcd na węzłach master.
Instalacja i konfiguracja etcd na węzłach master Ubuntu
Etcd to magazyn spójny i wysoce dostępny, przeznaczony do przechowywania kluczy oraz tworzenia kopii zapasowych wszystkich danych klastra. Klaster etcd musi być skonfigurowany przed skonfigurowaniem klastra HA Kubernetes z wieloma węzłami master. Zaczniemy od skonfigurowania węzła master 192.168.101.21 .
Installing and configuring etcd on the 192.168.101.21 machine.
Utwórz katalog konfiguracyjny dla etcd.
# mkdir /etc/etcd /var/lib/etcd
Przejdź do katalogu, do którego zostały skopiowane certyfikaty. To jest katalog domowy użytkownika kubernetes, w tym przypadku – /home/kubernetes-user/
Skopiuj certyfikaty do katalogu konfiguracyjnego etcd.
# cp ca.pem kubernetes.pem kubernetes-key.pem /etc/etcd
Zweryfikuj, czy pliki zostały skopiowane.
# ls -al /etc/etcd
Wróć do swojego poprzedniego katalogu
# cd -
Pobierz binaria etcd z repozytorium.
# wget https://github.com/coreos/etcd/releases/download/v3.3.9/etcd-v3.3.9-linux-amd64.tar.gz
Wypakuj archiwum etcd.
# tar xvzf etcd-v3.3.9-linux-amd64.tar.gz
Teraz przenieś pliki binarne etcd do /usr/local/bin/
# mv etcd-v3.3.9-linux-amd64/etcd* /usr/local/bin/
Utwórz plik jednostki systemd dla etcd.
# vim /etc/systemd/system/etcd.service
Dodaj poniższe ciągi do tego pliku.
[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
Przeładuj konfigurację menedżera systemd, aby zastosować zmienione konfiguracje z systemu plików i zregenerować drzewa zależności.
# systemctl daemon-reload
Ustaw, aby etcd startowało przy uruchomieniu systemu.
# systemctl enable etcd
Uruchom etcd. # systemctl start etcd
Wykonaj te same działania na drugim węźle master ( docker-nakivo22 – 192.168.101.21 oraz docker-nakivo23 – 192.168.101.22 ). Jedyną różnicą w działaniach niezbędnych dla tych węzłów master jest edytowanie pliku konfiguracyjnego etcd.service . Określ poprawne adresy IP dla każdego innego węzła master. Na przykład, plik konfiguracyjny etcd.service musi wyglądać następująco dla drugiego węzła master ( 192.168.101.22 ) bieżącego laboratorium testowego Kubernetes.
[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
Inicjowanie węzłów master w klastrze Kubernetes HA
Teraz możesz inicjować węzły master w swojej klastrze Kubernetes HA zainstalowanej na maszynach Ubuntu.
Inicjowanie węzła master 192.168.101.21
Na pierwszym węźle master wykonaj zakres operacji opisany poniżej.
Utwórz plik konfiguracyjny yaml dla kubeadm.
# vim config.yaml
Dodaj parametry konfiguracyjne do tego pliku:
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"
Sieć zdefiniowana jako podSubnet (10.244.0.0/16) musi być taka sama jak w pliku kube-flannel.yml .
Inicjalizuj maszynę Ubuntu jako węzeł master.
# kubeadm init --config=config.yaml
Czasami możesz zobaczyć ostrzeżenie o starej wersji pliku konfiguracyjnego:
Twój plik konfiguracyjny używa przestarzałej specyfikacji API: „kubeadm.k8s.io/v1alpha3”. Proszę użyć 'kubeadm config migrate –old-config old.yaml –new-config new.yaml’, które zapisze nową, podobną specyfikację używając nowszej wersji API.
Aktualizuj wersję pliku konfiguracyjnego poleceniem:
# kubeadm config migrate --old-config config.yaml --new-config config1.yaml
Inny błąd może wystąpić, gdy inicjalizujesz węzeł w klastrze Kubernetes z wieloma węzłami master, jeśli etcd nie jest uruchomiony:
[ERROR ExternalEtcdVersion]: Get https://192.168.101.21:2379/version: dial tcp 192.168.101.21:2379: connect: connection refused
Sprawdź, czy twój etcd działa. Możesz uruchomić etcd ręcznie:
# systemctl start etcd
Po pomyślnej inicjalizacji węzła master w klastrze Kubernetes działającej na Ubuntu, otrzymasz następujący komunikat wyświetlany na zrzucie ekranu. 
Wynik zakończonego powodzeniem wykonania tego polecenia zawiera wskazówkę, jak rozpocząć korzystanie z Twojego klastra, a także polecenia, które zawierają token oraz skrót certyfikatu potrzebne do dołączenia węzłów do klastra. Zapisz te ważne ciągi, ponieważ wkrótce będą potrzebne. Są one oznaczone żółtym kolorem na zrzucie ekranu i powtórzone poniżej.
Teraz możesz dołączyć dowolną liczbę węzłów zarządzających, kopiując urzędy certyfikacji
oraz klucze kont usługowych na każdy węzeł, a następnie uruchom następujące polecenie jako root:
kubeadm join 192.168.101.19:6443 --token sxm34y.p4rn4328vne0iihf
--discovery-token-ca-cert-hash sha256:bf3887f1565fcd48ff696da98a761ac1b70c6d38ba0ba3e4b1bf573000a302ca
--experimental-control-plane
Następnie możesz dołączyć dowolną liczbę węzłów roboczych, uruchamiając poniższe polecenie na każdym jako root:
kubeadm join 192.168.101.19:6443 --token sxm34y.p4rn4328vne0iihf
--discovery-token-ca-cert-hash sha256:bf3887f1565fcd48ff696da98a761ac1b70c6d38ba0ba3e4b1bf573000a302ca
Uruchom polecenia, aby rozpocząć korzystanie z zainicjalizowanego węzła w klastrze.
# mkdir -p $HOME/.kube
# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
# sudo chown $(id -u):$(id -g) $HOME/.kube/config
Sprawdź węzły dodane do klastra.
# kubectl get nodes
Kopiuj certyfikaty na dwa pozostałe węzły zarządzające
# scp -r /etc/kubernetes/pki kubernetes-user@192.168.101.22:~
# scp -r /etc/kubernetes/pki kubernetes-user@192.168.101.23:~
Inicjalizowanie węzła głównego 192.168.101.22
Uruchom polecenia na drugim węźle głównym (192.168.101.22).
Usuń certyfikat apiserver.crt oraz klucz apiserver.key znajdujące się w katalogu domowym (~) użytkownika kubernetes-user .
$ rm ~/pki/apiserver.*
Przenieś przechowywane w katalogu domowym certyfikaty do katalogu /etc/kubernetes/.
$ sudo mv ~/pki /etc/kubernetes/
Utwórz plik konfiguracyjny yaml dla kubeadm.
# vim config.yaml
Zawartość tego pliku yaml jest taka sama jak dla pierwszego węzła głównego 192.168.101.21 . Zobacz konfigurację dla inicjalizacji pierwszego węzła głównego powyżej. Możesz skopiować już utworzony plik użyty na pierwszym węźle głównym klastra Kubernetes HA zainstalowanym na Twoich maszynach Ubuntu.
Inicjalizuj drugi węzeł główny.
# kubeadm config migrate --old-config config.yaml --new-config config1.yaml
# kubeadm init --config=config1.yaml
Wynik jest taki sam jak wynik wyświetlany po inicjalizacji pierwszego węzła głównego w klastrze Kubernetes HA.
Podobnie, wykonaj polecenia, aby rozpocząć korzystanie z zainicjalizowanego węzła w klastrze.
# mkdir -p $HOME/.kube
# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
# sudo chown $(id -u):$(id -g) $HOME/.kube/config
Sprawdź węzły dodane do klastra.
# kubectl get nodes
Dwa węzły główne z trzech zostały dodane do klastra. Pozostał jeden węzeł główny do dodania.
Inicjalizowanie trzeciego (192.168.101.23) węzła głównego
Powtórz te same kroki, jakie wykonałeś przy inicjalizacji drugiego węzła (192.168.101.22) w klastrze. Nie zapomnij zanotować poleceń z tokenem i hashami do dodania węzłów do klastra, które są wyświetlane po inicjalizacji węzła głównego.
Sprawdź, czy wszystkie trzy węzły główne zostały pomyślnie dodane do klastra.
# kubectl get nodes
Instalowanie Flannel, aby naprawić status NotReady węzłów głównych w Kubernetes
Zainstalujmy Flannel. W przeciwieństwie do pierwszego przykładu, w którym nauczyłeś się, jak zainstalować Kubernetes na Ubuntu, aby stworzyć klaster jednoosobowy, w tym przykładzie Flannel zostanie zainstalowany za pomocą pliku yaml.
Uruchom polecenie, aby zainstalować Flannel i naprawić status NotReady węzłów, które są wyświetlane, ponieważ nie skonfigurowano jeszcze sieci nakładkowej. Utwórz plik kube-flannel.yaml za pomocą edytora tekstu vim, na przykład na pierwszym węźle głównym.
# kubectl apply -f kube-flannel.yml
Pamiętaj o adresie podSubnet zdefiniowanym w pliku config.yaml . Adres sieci musi być taki sam w pliku kube-flannel.yaml .
Sprawdź swoje węzły i ich status.
# kubectl get nodes
Teraz wszystkie węzły główne działają poprawnie.
Dodawanie węzłów roboczych do klastra
Gdy zainicjujesz wszystkie węzły główne, możesz dodać węzły robocze do swojego klastra Kubernetes. Dodajmy pierwszy węzeł roboczy ( 192.168.101.31 ) do klastra HA Kubernetes wdrożonego na maszynach Ubuntu. Użyj polecenia, które zostało wyświetlone po inicjalizacji węzłów głównych (polecenie zawierające token i hash), aby węzeł roboczy dołączył do klastra. Uruchom polecenie na maszynie 192.168.101.31 .
# kubeadm join 192.168.101.19:6443 --token kxl1gf.6ddalutd60n0ez45
--discovery-token-ca-cert-hash sha256:bf3887f1565fcd48ff696da98a761ac1b70c6d38ba0ba3e4b1bf573000a302ca
Sprawdź węzły klastra HA Kubernetes, aby upewnić się, że węzeł roboczy został dodany. Teraz na liście węzłów można również zobaczyć maszynę z proxy HA.
# kubectl get nodes
Podobnie, dodaj inne węzły robocze do klastra wysokiej dostępności Kubernetes zainstalowanego na maszynach Ubuntu. Możesz dodawać więcej węzłów roboczych w dowolnym czasie w zależności od swoich potrzeb. Na tym kończy się dzisiejszy samouczek.
Wnioski
Instalacja Kubernetes na Ubuntu nie jest tak trudna, jak się może wydawać na pierwszy rzut oka. Trzeba włożyć trochę wysiłku w wdrażanie klastra Kubernetes, ale w rezultacie uzyskujesz wiele korzyści, takich jak centralne prostsze zarządzanie, wysoka skalowalność i równoważenie obciążenia. Najprostszy typ wdrożenia Kubernetes to wdrożenie jednego węzła głównego – powinieneś zainstalować Kubernetes na węzłach Ubuntu, w tym węzłach głównych i roboczych. Jeśli potrzebujesz bardziej niezawodnej infrastruktury do uruchamiania aplikacji w kontenerach, rozważ wdrażanie klastra Kubernetes typu multi-master, znanego jako klaster Kubernetes o wysokiej dostępności. Ten rodzaj wdrażania Kubernetes eliminuje pojedynczy punkt awarii, a klaster może nadal funkcjonować nawet w przypadku awarii niektórych węzłów master.
W przypadku obu typów wdrażania należy skonfigurować dostęp SSH, ustawić statyczne adresy IP i nazwy hostów, zainstalować Docker, wyłączyć korzystanie z partycji swap, a na koniec zainstalować komponenty Kubernetes, takie jak kubeadm, kubectl, kubelet, oraz skonfigurować Flannel do obsługi sieci nakładkowej. W przypadku wdrażania klastra Kubernetes o wysokiej dostępności (HA) konieczne jest również skonfigurowanie proxy HA na oddzielnej maszynie, wygenerowanie certyfikatów oraz skonfigurowanie klastra etcd. Większość etapów konfiguracji Kubernetes, tworzenia wdrażania, a także uruchamiania podów można wykonać na dwa sposoby: ręcznie, za pomocą poleceń udostępnianych przez interfejs wiersza poleceń, oraz przy użyciu plików konfiguracyjnych YAML. Korzystanie z plików YAML pozwala na tworzenie bardziej złożonych struktur i sprawia, że proces administracji jest wygodniejszy.
Kubernetes można zainstalować w systemie Ubuntu, zarówno na maszynach fizycznych, jak i wirtualnych. Jeśli Kubernetes jest zainstalowany na maszynach wirtualnych działających w środowisku vSphere, można zapewnić dodatkową ochronę, korzystając z usługi Klaster VMware o wysokiej dostępności z funkcją Fault Tolerance. Logika wdrażania Kubernetes omówiona w tym wpisie na blogu może być również wykorzystana do instalacji Kubernetes w innych dystrybucjach systemu Linux.
