Hur man installerar Kubernetes med Kubeadm

Kubernetes introducerades i en tidigare artikel, "Komma igång med Kubernetes på Amazon Web Services (AWS)." Kubernetes diskuterades också i en annan artikel, "Using Kubernetes (K8s) on IBM Bluemix." Kubernetes kan installeras på ren metall på nästan alla operativsystem inklusive Fedora, CentOS, Ubuntu och CoreOS för utvecklingsändamål.

Problemet

Kubernetes-installation på ren metall innebär att flera kommandon körs för att ställa in en masternod, arbetarnoder, pod-nätverk och etc.

Lösningen

Kubernetes 1.4 introducerar ett nytt verktyg som heter kubeadm för att starta upp ett Kubernetes-kluster. kubeadm startar ett Kubernetes-kluster med två kommandon. Efter installation av Docker, kubectl och kubelet kan masternoden startas med kubeadm init och arbetarnoder läggs till med kubeadm join .

I den här artikeln ska vi använda följande procedur för att installera och starta upp ett Kubernetes-kluster och därefter testa klustret:

1. Starta tre nya Ubuntu-instanser på Amazon EC2.
2. På alla Ubuntu-instanser, installera Docker, kubeadm, kubectl och kubelet.
3. Från en av Ubuntu-instanserna, initiera Kubernetes cluster Master med följande kommando:

   kubeadm init

4. Använd Calico Pod-nätverkspolicy kubeadm/calico.yaml .
5. Gå med de andra två Ubuntu-instanserna (noder) med master med kubeadm join --token= .
6. På master listas tre noder med 'kubectl get nodes.'
7. Kör ett program på master:

   kubectl -s http://localhost:8080 run nginx
      --image=nginx
      --replicas=3 --port=80
   

8. Lista poddarna:

   kubectl get pods -o wide

9. Avinstallera Kubernetes-klustret.

   kubeadm reset

Den här artikeln har följande avsnitt:

• Ställa in miljön
• Installera Docker, kubeadm, kubectl och kubelet på varje värd
• Initiering av mastern
• Installera Calico Pod Network
• Ansluta noder till klustret
• Installera ett exempelprogram
• Avinstallera klustret
• Begränsningar
• Ytterligare utvecklingar i kubeadm
• Slutsats

Ställa in miljön

kubeadm Verktyget kräver att följande maskiner kör en av Ubuntu 16.04+, HypriotOS v1.0.1+ eller CentOS 7 som körs på dem.

• En maskin för huvudnoden
• En eller flera maskiner för arbetarnoderna

Minst 1 GB RAM krävs på var och en av maskinerna. Vi har använt tre Ubuntu-maskiner som körs på Amazon EC2 för att starta upp ett kluster med en enda huvudnod och två arbetarnoder. De tre Ubuntu-maskinerna visas i figur 1.

Figur 1: Ubuntu-maskiner

Installera Docker, kubeadm, kubectl och kubelet på varje värd

I det här avsnittet ska vi installera Docker, kubelet, kubectl och kubeadm på var och en av de tre maskinerna. De installerade komponenterna diskuteras i Tabell 1.

Tabell 1: Komponenter att installera

Skaffa den offentliga IP-adressen var och en av de tre maskinerna och SSH logga in på var och en av maskinerna:

ssh -i "docker.pem" [email protected]
ssh -i "docker.pem" [email protected]
ssh -i "docker.pem" [email protected]

Kommandona för att installera binärfilerna måste köras som root; ställ därför in användaren på root.

sudo su -

Kör följande kommandon på var och en av datorerna:

curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg
   | apt-key add -
cat <<EOF > /etc/apt/sources.list.d/kubernetes.list
deb http://apt.kubernetes.io/ kubernetes-xenial main
EOF

Det första kommandot laddar ner de nödvändiga paketen för Kubernetes, som visas i utdata i figur 2.

Figur 2: Laddar ner paket för Kubernetes

Kommandot 2 laddar ner paketlistorna från arkiven och uppdaterar dem med de senaste versionerna av paketen.

apt-get update

Utgången visas i figur 3.

Figur 3: Uppdaterar förrådspaket

Installera sedan Docker:

# Install docker if you don't have it already.
apt-get install -y docker.io

Docker installeras, som visas i kommandoutgången i figur 4.

Figur 4: Installerar Docker

Och installera sedan kubelet (kärnkomponent i Kubernetes), kubeadm (bootstrapping-verktyg), kubectl (klusterhanteringsverktyg) och kubernetes-cni (nätverksplugin):

apt-get install -y kubelet kubeadm kubectl kubernetes-cni

Utdata från de föregående kommandona visas i figur 5.

Figur 5: Installera kubelet, kubeadm, kubectln och kubernetes-cni

Initiering av mastern

Initiera sedan mastern som etcd-databasen och API-servern körs på. Kubelet startar Pods för att köra dessa komponenter. Kör följande kommando som automatiskt upptäcker IP-adresserna:

kubeadm init

Som visas i kommandoutgången körs först några kontroller före flygning för att validera systemtillståndet. Därefter genereras en master/tokens-token som ska användas som en ömsesidig autentiseringsnyckel för arbetarnoder som vill ansluta sig till klustret. Därefter genereras en självsignerad certifikatutfärdarnyckel och certifikat för att tillhandahålla identiteter till var och en av noderna i klustret för kommunikation med klienterna. En API-servernyckel och ett certifikat skapas för API-servern för kommunikation med klienterna. En util/kubeconfig fil skapas för att kubelet ska ansluta till API-servern och en annan util/kubeconfig fil skapas för administrationen. Därefter skapas API-klientkonfigurationen. Utdata från kubeadm init kommandot visas i figur 6.

Figur 6: Kör kubeadm init

Alla styrplanskomponenter blir klara. Den första noden blir klar och en testinstallation görs. Viktiga tilläggskomponenter kube-discovery, kube-proxy och kube-dns skapas också, som visas i kommandoutgången i figur 7. Kubernetes master initieras framgångsrikt. Ett kommando med följande syntax genereras; den måste köras på maskiner (noder) som ska gå med i klustret.

kubeadm join -token=<token> <IP Address of the master node>

Det föregående kommandot måste kopieras och behållas för efterföljande användning på arbetarnoder.

Figur 7: Kubernetes master initierad

Som standard är masternoderna inte schemaläggbara och görs så genom att använda den "dedikerade" fläcken. Masternoden kan göras schemaläggningsbar med följande kommando:

kubectl taint nodes --all dedicated-

kubeadm kommandot stöder några andra alternativ (se tabell 2) som vi inte behövde använda men som kan användas för att åsidosätta standardkommandot.

Tabell 2: Kubeadm kommandoalternativ

Installera Calico Pod Network

För att Pods ska kunna kommunicera med varandra måste ett Pod-nätverkstillägg vara installerat. Calico tillhandahåller en kubeadm-värd installationskonfiguration i form av en ConfigMap på http://docs.projectcalico.org/master/getting-started/kubernetes/installation/hosted/kubeadm/calico.yaml som vi ska använda i det här avsnittet för att installera ett Pod-nätverk. Kör följande kommando på huvudnoden för att installera Pod-nätverket:

kubectl apply -f
   http://docs.projectcalico.org/master/getting-started/
   kubernetes/installation/hosted/kubeadm/calico.yaml

Alternativt kan du ladda ner calico.yaml och kopiera till huvudnoden:

scp -i "docker.pem" calico.yaml [email protected]:~

Kör sedan följande kommando:

kubectl apply -f calico.yaml

Calico och ett enstaka nod etcd-kluster installeras, som visas i figur 8.

Figur 8: Installerar Calico Policy

Lista sedan alla Pods i alla Kubernetes namnrymder.

kubectl get pods --all-namespaces

kube-dns Pod måste vara igång, enligt listan i figur 9.

Figur 9: Lista Pods i alla namnutrymmen

Ansluter noder till klustret

I det här avsnittet ska vi sammanfoga arbetarnoder till klustret genom att använda kubeadm join kommando, som har följande syntax:

kubeadm join --token=<token> <master-ip>

Alternativt kan kubeadm gå med kommandot kan köras med --skip-preflight-checks alternativet för att hoppa över den preliminära valideringen.

kubeadm-anslutningen kommandot använder den medföljande token för att kommunicera med API-servern och hämta rot-CA-certifikatet och skapar ett lokalt nyckelpar. Därefter skickas en begäran om certifikatsignering (CSR) till API-servern för signering och den lokala kubelet konfigureras för att ansluta till API-servern.

Kör kubeadm join kommandot kopierat från utdata från kubeadm init kommandot på var och en av Ubuntu-datorerna som ska gå med i klustret.

Först, SSH logga in på Ubuntu-instansen/-erna:

ssh -i "docker.pem" [email protected]

och

ssh -i "docker.pem" [email protected]

Kör sedan kubeadm join kommando. Först utförs vissa kontroller före flygning. Den angivna token är validerad. Därefter används nodupptäckt. En klient för upptäckt av klusterinformation skapas och information begärs från API-servern. Ett klusterinfoobjekt tas emot och en signatur verifieras genom att använda den givna token. Klusterinformationssignaturen och innehållet har visat sig vara giltigt och nodupptäckten är klar. Därefter utförs nodbootstrapping, där API-ändpunkterna https://10.0.0.129:6443 används för att upprätta en anslutning. Därefter görs en begäran om certifikatsignering (csr) genom att använda en API-klient för att få ett unikt certifikat för noden. När ett signerat certifikat har tagits emot från API-servern genereras en kubelet-konfigurationsfil. Meddelandet "Node join complete" listat i figur 10 indikerar att noden har anslutit sig till klustret.

Figur 10: Ansluter en nod till klustret

Kör samma kommando på den andra Ubuntu-maskinen. Den andra noden ansluter sig också till klustret, vilket indikeras av utgången i figur 11.

Figur 11: Förenar den andra noden till klustret

På huvudnoden, kör följande kommando för att lista noderna:

kubectl get nodes

Huvudnoden och de två arbetarnoderna bör listas, som visas i figur 12.

Figur 12: Lista Kubernetes klusternoder

Installera ett exempelprogram

Därefter ska vi testa klustret. Kör följande kommando för att köra en nginx -baserat Pod-kluster som består av tre repliker:

kubectl -s http://localhost:8080 run nginx
   --image=nginx
   --replicas=3 --port=80

Lista distributionerna:

kubectl get deployments

Lista de klusteromfattande poddarna:

kubectl get pods -o wide

Exponera distributionen som en tjänst av typen LoadBalancer :

kubectl expose deployment nginx --port=80 --type=LoadBalancer

Lista tjänsterna:

kubectl get services

Utdata från de föregående kommandona indikerar nginx distribution skapades och de tre Pods kör över de två arbetarnoderna i klustret. En tjänst som kallas "nginx" skapas också, som visas i figur 13.

Figur 13: Köra ett nginx Pod-kluster

Kopiera tjänstens kluster-IP. Kör curl-kommandot för att anropa tjänsten:

curl 10.0.0.99

HTML-uppmärkningen från tjänsten får utdata, som visas i figur 14.

Figur 14: Anropar nginx-tjänst

Avinstallera klustret

För att avinstallera klustret som installerats av kubeadm, kör följande kommando:

kubeadm reset

Klustret avinstalleras, som visas i figur 15.

Figur 15: Avinstallera/återställa Kubernetes-kluster

Begränsningar

kubeadm har flera begränsningar och rekommenderas endast för utvecklingsanvändning. Begränsningarna för kubeadm är följande;

• Endast ett fåtal operativsystem stöds:Ubuntu 16.04+, CentOS 7, HypriotOS v1.0.1+.
• Ej lämplig för produktionsanvändning.
• Integration av molnleverantörer är experimentell.
• Ett kluster med endast en enda master med en enda etcd-databas skapas. Hög tillgänglighet stöds inte, vilket innebär att mastern är en enda felpunkt (SPOF).
• HostPort och HostIP-funktioner stöds inte.
• Några andra kända problem när kubeadm används med RHEL/CentOS 7 och VirtualBox.

Ytterligare utvecklingar i kubeadm

kubeadm är i alfa i Kubernetes v 1.5 och är i beta sedan Kubernetes 1.6. Mindre korrigeringar och förbättringar fortsätter att göras av kubeadm med varje ny Kubernetes-version:

• Med Kubernetes 1.7 skrivs ändringar av interna klusterresurser som installerats med kubeadm över vid uppgradering från v 1.6 till v 1.7.
• I Kubernetes 1.8, standard Bootstrap-token skapad med kubeadm init blir ogiltig och raderas efter 24 timmar efter att den skapats för att begränsa exponeringen av den värdefulla referensen. kubeadm-anslutningen kommandot delegerar TLS-bootstrapping till kubelet iteslf istället för att implementera om processen. Bootstrap KubeConfig filen skrivs till /etc/kubernetes/bootstrap-kubelet-conf med kubeadm join .

Slutsats

I den här artikeln använde vi kubeadm-verktygsfunktionen som är tillgänglig sedan Kubernetes v1.4 för att starta upp ett Kubernetes-kluster. Först installeras de nödvändiga binärfilerna för Docker, kubectl, kubelet och kubeadm. Därefter, kubeadm init kommandot används för att initiera masternoden i klustret. Slutligen, kubeadm går med kommandot används för att koppla samman arbetarnoder med klustret. Ett exempel på nginx applikationen körs för att testa klustret.