Hoe Kubernetes te installeren met Kubeadm

Kubernetes werd geïntroduceerd in een eerder artikel, "Aan de slag met Kubernetes op Amazon Web Services (AWS)." Kubernetes werd ook besproken in een ander artikel, "Using Kubernetes (K8s) on IBM Bluemix." Kubernetes kan voor ontwikkelingsdoeleinden op bare metal worden geïnstalleerd op bijna elk besturingssysteem, inclusief Fedora, CentOS, Ubuntu en CoreOS.

Het probleem

Kubernetes-installatie op bare metal omvat het uitvoeren van verschillende opdrachten voor het opzetten van een hoofdknooppunt, werkknooppunten, pod-netwerk en etcd.

De oplossing

Kubernetes 1.4 introduceert een nieuwe tool genaamd kubeadm voor het bootstrappen van een Kubernetes-cluster. De kubeadm bootstraps een Kubernetes-cluster met twee opdrachten. Na het installeren van Docker, kubectl en kubelet, kan het hoofdknooppunt worden gestart met kubeadm init en werkknooppunten toegevoegd met kubeadm join .

In dit artikel zullen we de volgende procedure gebruiken om een ​​Kubernetes-cluster te installeren en op te starten en vervolgens het cluster te testen:

1. Start drie nieuwe Ubuntu-instanties op Amazon EC2.
2. Installeer op alle Ubuntu-instanties Docker, kubeadm, kubectl en kubelet.
3. Initialiseer vanuit een van de Ubuntu-instanties de Kubernetes-clustermaster met de volgende opdracht:

   kubeadm init

4. Pas het Calico Pod-netwerkbeleid toe kubeadm/calico.yaml .
5. Voeg de andere twee Ubuntu-instanties (knooppunten) samen met master met kubeadm join --token= .
6. Op de master worden drie nodes weergegeven met 'kubectl get nodes'.
7. Voer een applicatie uit op master:

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

8. Laat de pods zien:

   kubectl get pods -o wide

9. Verwijder het Kubernetes-cluster.

   kubeadm reset

Dit artikel heeft de volgende secties:

• De omgeving instellen
• Docker, kubeadm, kubectl en kubelet op elke host installeren
• De master initialiseren
• Het Calico Pod-netwerk installeren
• Knooppunten aan het cluster toevoegen
• Een voorbeeldtoepassing installeren
• De cluster verwijderen
• Beperkingen
• Verdere ontwikkelingen in kubeadm
• Conclusie

De omgeving instellen

De kubeadm tool vereist de volgende machines waarop Ubuntu 16.04+, HypriotOS v1.0.1+ of CentOS 7 draait.

• Eén machine voor het hoofdknooppunt
• Een of meer machines voor de werkknooppunten

Op elk van de machines is minimaal 1 GB RAM vereist. We hebben drie Ubuntu-machines gebruikt die op Amazon EC2 draaien om een ​​cluster met een enkel hoofdknooppunt en twee werkknooppunten op te starten. De drie Ubuntu-machines worden getoond in Afbeelding 1.

Figuur 1: Ubuntu-machines

Docker, kubeadm, kubectl en kubelet op elke host installeren

In deze sectie zullen we Docker, kubelet, kubectl en kubeadm op elk van de drie machines installeren. De geïnstalleerde componenten worden besproken in Tabel 1.

Tabel 1: Te installeren componenten

Verkrijg het openbare IP-adres van elk van de drie machines en log SSH in op elk van de machines:

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

De opdrachten om de binaire bestanden te installeren moeten worden uitgevoerd als root; stel de gebruiker daarom in op root.

sudo su -

Voer de volgende opdrachten uit op elk van de machines:

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

De eerste opdracht downloadt de vereiste pakketten voor Kubernetes, zoals weergegeven in de uitvoer in Afbeelding 2.

Figuur 2: Pakketten downloaden voor Kubernetes

De opdracht 2 downloadt de pakketlijsten uit de repositories en werkt ze bij met de nieuwste versies van de pakketten.

apt-get update

De uitvoer wordt getoond in figuur 3.

Figuur 3: Repository-pakketten bijwerken

Installeer vervolgens Docker:

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

Docker wordt geïnstalleerd, zoals weergegeven in de opdrachtuitvoer in Afbeelding 4.

Figuur 4: Docker installeren

En installeer vervolgens kubelet (kerncomponent van Kubernetes), kubeadm (bootstrapping-tool), kubectl (clusterbeheertool) en kubernetes-cni (netwerkplug-in):

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

De uitvoer van de voorgaande commando's wordt getoond in Afbeelding 5.

Figuur 5: Kubelet, kubeadm, kubectln en kubernetes-cni installeren

De master initialiseren

Initialiseer vervolgens de master waarop de etcd-database en de API-server draaien. De kubelet start Pods om deze componenten uit te voeren. Voer de volgende opdracht uit die de IP-adressen automatisch detecteert:

kubeadm init

Zoals te zien is in de uitvoer van de opdracht, worden eerst enkele preflight-controles uitgevoerd om de systeemstatus te valideren. Vervolgens wordt een master/tokens-token gegenereerd dat moet worden gebruikt als wederzijdse verificatiesleutel voor werkknooppunten die lid willen worden van het cluster. Vervolgens worden een zelfondertekende sleutel en certificaat van de certificeringsinstantie gegenereerd om identiteiten te verstrekken aan elk van de knooppunten in het cluster voor communicatie met de clients. Er worden een API-serversleutel en -certificaat gemaakt voor de API-server voor communicatie met de clients. Een util/kubeconfig bestand wordt gemaakt zodat de kubelet verbinding kan maken met de API-server en een andere util/kubeconfig bestand wordt aangemaakt voor de administratie. Vervolgens wordt de API-clientconfiguratie gemaakt. De uitvoer van de kubeadm init commando wordt getoond in Afbeelding 6.

Figuur 6: Kubeadm init uitvoeren

Alle componenten van het besturingsvlak worden gereed. Het eerste knooppunt wordt gereed en er wordt een testimplementatie gemaakt. Essentiële add-oncomponenten kube-discovery, kube-proxy en kube-dns worden ook gemaakt, zoals weergegeven in de opdrachtuitvoer in Afbeelding 7. De Kubernetes-master wordt met succes geïnitialiseerd. Er wordt een opdracht met de volgende syntaxis gegenereerd; het moet worden uitgevoerd op machines (knooppunten) die zich bij het cluster moeten voegen.

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

De voorgaande opdracht moet worden gekopieerd en bewaard voor later gebruik op werkknooppunten.

Figuur 7: Kubernetes-master geïnitialiseerd

Standaard zijn de hoofdknooppunten niet planbaar en worden ze zo gemaakt met behulp van de "dedicated" taint. Het hoofdknooppunt kan planbaar worden gemaakt met het volgende commando:

kubectl taint nodes --all dedicated-

De kubeadm command ondersteunt enkele andere opties (zie Tabel 2) die we niet hoefden te gebruiken, maar die konden worden gebruikt om de standaardopdracht te negeren.

Tabel 2: Kubeadm-opdrachtopties

Het Calico Pod-netwerk installeren

Om Pods met elkaar te laten communiceren, moet een Pod-netwerk-add-on zijn geïnstalleerd. Calico biedt een door kubeadm gehoste installatieconfiguratie in de vorm van een ConfigMap op http://docs.projectcalico.org/master/getting-started/kubernetes/installation/hosted/kubeadm/calico.yaml die we in deze sectie zullen gebruiken om een ​​pod-netwerk te installeren. Voer de volgende opdracht uit op het hoofdknooppunt om het Pod-netwerk te installeren:

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

U kunt ook de calico.yaml . downloaden en kopieer naar het hoofdknooppunt:

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

Voer vervolgens het volgende commando uit:

kubectl apply -f calico.yaml

Calico en een enkele node etcd-cluster worden geïnstalleerd, zoals weergegeven in Afbeelding 8.

Figuur 8: Calico Policy installeren

Maak vervolgens een lijst van alle Pods in alle Kubernetes-naamruimten.

kubectl get pods --all-namespaces

De kube-dns Pod moet actief zijn, zoals weergegeven in Afbeelding 9.

Figuur 9: Pods weergeven in alle naamruimten

Knooppunten aan de cluster koppelen

In deze sectie voegen we werkknooppunten toe aan het cluster met behulp van de kubeadm-join commando, dat de volgende syntaxis heeft:

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

Optioneel kan de kubeadm join commando kan worden uitgevoerd met de --skip-preflight-checks optie om de voorlopige validatie over te slaan.

De kubeadm-join commando gebruikt het geleverde token om met de API-server te communiceren en het root-CA-certificaat te verkrijgen, en maakt een lokaal sleutelpaar aan. Vervolgens wordt een certificaatondertekeningsverzoek (CSR) naar de API-server gestuurd voor ondertekening en wordt de lokale kubelet geconfigureerd om verbinding te maken met de API-server.

Voer de kubeadm-join uit commando gekopieerd uit de uitvoer van de kubeadm init commando op elk van de Ubuntu-machines die zich bij het cluster moeten voegen.

Log eerst SSH in op de Ubuntu-instantie(s):

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

en

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

Voer vervolgens de kubeadm-join . uit opdracht. Eerst worden enkele pre-flight checks uitgevoerd. Het opgegeven token is gevalideerd. Vervolgens wordt knooppuntdetectie gebruikt. Er wordt een clusterinfo-ontdekkingsclient gemaakt en er wordt informatie opgevraagd bij de API-server. Een clusterinfo-object wordt ontvangen en een handtekening wordt geverifieerd met behulp van het opgegeven token. De handtekening en inhoud van de clusterinfo zijn geldig bevonden en de detectie van het knooppunt is voltooid. Vervolgens wordt node-bootstrapping uitgevoerd, waarbij de API-eindpunten https://10.0.0.129:6443 worden gebruikt om een ​​verbinding tot stand te brengen. Vervolgens wordt een certificaatondertekeningsverzoek (csr) gedaan door een API-client te gebruiken om een ​​uniek certificaat voor het knooppunt te krijgen. Zodra een ondertekend certificaat is ontvangen van de API-server, wordt een kubelet-configuratiebestand gegenereerd. Het bericht "Node join complete" in Afbeelding 10 geeft aan dat de node zich bij het cluster heeft gevoegd.

Figuur 10: Een knooppunt toevoegen aan het cluster

Voer op dezelfde manier dezelfde opdracht uit op de andere Ubuntu-machine. Het andere knooppunt voegt zich ook bij het cluster, zoals aangegeven door de uitvoer in Afbeelding 11.

Figuur 11: Deelnemen aan tweede knooppunt bij cluster

Voer op het hoofdknooppunt de volgende opdracht uit om de knooppunten weer te geven:

kubectl get nodes

Het hoofdknooppunt en de twee werkknooppunten moeten worden weergegeven, zoals weergegeven in Afbeelding 12.

Figuur 12: Lijst met Kubernetes-clusterknooppunten

Een voorbeeldtoepassing installeren

Vervolgens gaan we het cluster testen. Voer de volgende opdracht uit om een ​​nginx . uit te voeren -gebaseerd Pod-cluster bestaande uit drie replica's:

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

Maak een lijst van de implementaties:

kubectl get deployments

Maak een lijst van de clusterbrede pods:

kubectl get pods -o wide

Stel de implementatie bloot als een service van het type LoadBalancer :

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

Lijst van de diensten:

kubectl get services

De uitvoer van de voorgaande commando's geeft de nginx . aan implementatie is gemaakt en de drie pods lopen over de twee werkknooppunten in het cluster. Er wordt ook een service met de naam "nginx" gemaakt, zoals weergegeven in Afbeelding 13.

Figuur 13: Een nginx Pod-cluster uitvoeren

Kopieer het cluster-IP van de service. Voer het curl-commando uit om de service op te roepen:

curl 10.0.0.99

De HTML-opmaak van de service wordt uitgevoerd, zoals weergegeven in Afbeelding 14.

Figuur 14: De nginx-service aanroepen

De Cluster verwijderen

Voer de volgende opdracht uit om het door kubeadm geïnstalleerde cluster te verwijderen:

kubeadm reset

Het cluster wordt verwijderd, zoals weergegeven in Afbeelding 15.

Figuur 15: Kubernetes-cluster verwijderen/resetten

Beperkingen

kubeadm heeft verschillende beperkingen en wordt alleen aanbevolen voor gebruik in ontwikkeling. De beperkingen van kubeadm zijn als volgt;

• Er worden maar een paar besturingssystemen ondersteund:Ubuntu 16.04+, CentOS 7, HypriotOS v1.0.1+.
• Niet geschikt voor productiegebruik.
• De integratie van cloudproviders is experimenteel.
• Er wordt een cluster gemaakt met slechts een enkele master met een enkele etcd-database erop. Hoge beschikbaarheid wordt niet ondersteund, wat inhoudt dat de master een single point of failure (SPOF) is.
• HostPort- en HostIP-functionaliteit worden niet ondersteund.
• Enkele andere bekende problemen wanneer kubeadm wordt gebruikt met RHEL/CentOS 7 en VirtualBox.

Verdere ontwikkelingen in kubeadm

kubeadm is in alfa in Kubernetes v 1.5 en is in bèta sinds Kubernetes 1.6. Bij elke nieuwe Kubernetes-versie blijven kleine fixes en verbeteringen aangebracht aan kubeadm:

• Met Kubernetes 1.7 worden wijzigingen aan de interne clusterbronnen die zijn geïnstalleerd met kubeadm overschreven bij het upgraden van v 1.6 naar v 1.7.
• In Kubernetes 1.8, het standaard Bootstrap-token gemaakt met kubeadm init wordt ongeldig en wordt 24 uur na het maken verwijderd om de blootstelling van de waardevolle referentie te beperken. De kubeadm-join opdracht delegeert de TLS-bootstrapping naar de kubelet zelf in plaats van het proces opnieuw te implementeren. De bootstrap KubeConfig bestand wordt geschreven naar /etc/kubernetes/bootstrap-kubelet-conf met kubeadm join .

Conclusie

In dit artikel hebben we de kubeadm-toolfunctie gebruikt die beschikbaar is sinds Kubernetes v1.4 om een ​​Kubernetes-cluster op te starten. Eerst worden de vereiste binaire bestanden voor Docker, kubectl, kubelet en kubeadm geïnstalleerd. Vervolgens wordt de kubeadm init opdracht wordt gebruikt om het hoofdknooppunt in het cluster te initialiseren. Eindelijk, de kubeadm join opdracht wordt gebruikt om werkknooppunten samen te voegen met het cluster. Een voorbeeld nginx applicatie wordt uitgevoerd om het cluster te testen.