Sådan installeres Kubernetes ved hjælp af Kubeadm

Kubernetes blev introduceret i en tidligere artikel, "Kom godt i gang med Kubernetes på Amazon Web Services (AWS)." Kubernetes blev også diskuteret i en anden artikel, "Brug af Kubernetes (K8s) på IBM Bluemix." Kubernetes kan installeres på bart metal på næsten alle operativsystemer inklusive Fedora, CentOS, Ubuntu og CoreOS til udviklingsformål.

Problemet

Kubernetes-installation på bart metal involverer kørsel af flere kommandoer til opsætning af en masterknude, arbejdsknudepunkter, pod-netværk osv.

Løsningen

Kubernetes 1.4 introducerer et nyt værktøj kaldet kubeadm til bootstrapping af en Kubernetes-klynge. kubeadm bootstraps en Kubernetes-klynge med to kommandoer. Efter installation af Docker, kubectl og kubelet, kan masterknuden startes med kubeadm init og arbejdernoder tilføjet med kubeadm join .

I denne artikel skal vi bruge følgende procedure til at installere og bootstrap en Kubernetes-klynge og efterfølgende teste klyngen:

1. Start tre nye Ubuntu-forekomster på Amazon EC2.
2. På alle Ubuntu-forekomster skal du installere Docker, kubeadm, kubectl og kubelet.
3. Fra en af ​​Ubuntu-forekomsterne skal du initialisere Kubernetes cluster Master med følgende kommando:

   kubeadm init

4. Anvend Calico Pod-netværkspolitik kubeadm/calico.yaml .
5. Forbind de to andre Ubuntu-instanser (noder) med master med kubeadm join --token= .
6. På master bliver tre noder opført med 'kubectl get nodes.'
7. Kør et program på master:

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

8. Skriv en liste over pods:

   kubectl get pods -o wide

9. Afinstaller Kubernetes-klyngen.

   kubeadm reset

Denne artikel har følgende sektioner:

• Indstilling af miljøet
• Installation af Docker, kubeadm, kubectl og kubelet på hver vært
• Initialisering af masteren
• Installation af Calico Pod-netværket
• Sammenslutning af noder til klyngen
• Installation af en prøveapplikation
• Afinstallation af klyngen
• Begrænsninger
• Yderligere udviklinger i kubeadm
• Konklusion

Indstilling af miljøet

kubeadm værktøj kræver følgende maskiner, der kører en af ​​Ubuntu 16.04+, HypriotOS v1.0.1+ eller CentOS 7, der kører på dem.

• Én maskine til masternoden
• En eller flere maskiner til arbejdernoderne

Der kræves mindst 1 GB RAM på hver af maskinerne. Vi har brugt tre Ubuntu-maskiner, der kører på Amazon EC2, til at starte en klynge med en enkelt masterknude og to arbejdsknudepunkter. De tre Ubuntu-maskiner er vist i figur 1.

Figur 1: Ubuntu-maskiner

Installation af Docker, kubeadm, kubectl og kubelet på hver vært

I dette afsnit skal vi installere Docker, kubelet, kubectl og kubeadm på hver af de tre maskiner. De installerede komponenter er beskrevet i tabel 1.

Tabel 1: Komponenter, der skal installeres

Få den offentlige IP-adresse hver af de tre maskiner og SSH log ind på hver af maskinerne:

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

Kommandoerne til at installere binære filer skal køres som root; sæt derfor brugeren til root.

sudo su -

Kør følgende kommandoer på hver af maskinerne:

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

Den første kommando downloader de nødvendige pakker til Kubernetes, som vist i outputtet i figur 2.

Figur 2: Downloader pakker til Kubernetes

Kommandoen 2 downloader pakkelisterne fra lagrene og opdaterer dem med de nyeste versioner af pakkerne.

apt-get update

Outputtet er vist i figur 3.

Figur 3: Opdatering af lagerpakker

Installer derefter Docker:

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

Docker bliver installeret, som vist i kommandooutputtet i figur 4.

Figur 4: Installerer Docker

Og installer efterfølgende kubelet (kernekomponent i Kubernetes), kubeadm (bootstrapping-værktøj), kubectl (klyngestyringsværktøj) og kubernetes-cni (netværksplugin):

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

Outputtet fra de foregående kommandoer er vist i figur 5.

Figur 5: Installation af kubelet, kubeadm, kubectln og kubernetes-cni

Initialisering af Master

Derefter initialiseres masteren, som etcd-databasen og API-serveren kører på. Kubelet starter Pods for at køre disse komponenter. Kør følgende kommando, der automatisk registrerer IP-adresserne:

kubeadm init

Som vist i kommandooutputtet, køres der først nogle kontroller før flyvningen for at validere systemtilstanden. Efterfølgende genereres et master/tokens-token, der skal bruges som en gensidig godkendelsesnøgle for arbejdernoder, der ønsker at tilslutte sig klyngen. Dernæst genereres en selvsigneret certifikatmyndighedsnøgle og et certifikat for at give identiteter til hver af noderne i klyngen til kommunikation med klienterne. En API-servernøgle og et certifikat oprettes til API-serveren til kommunikation med klienterne. En util/kubeconfig fil oprettes for kubelet at forbinde til API-serveren og en anden util/kubeconfig fil oprettes til administrationen. Efterfølgende oprettes API-klientkonfigurationen. Outputtet fra kubeadm init kommandoen er vist i figur 6.

Figur 6: Kører kubeadm init

Alle kontrolplankomponenter bliver klar. Den første node bliver klar, og en testimplementering udføres. Væsentlige tilføjelseskomponenter kube-discovery, kube-proxy og kube-dns bliver også oprettet, som vist i kommandooutputtet i figur 7. Kubernetes-masteren initialiseres med succes. En kommando med følgende syntaks genereres; det skal køres på maskiner (knudepunkter), der skal slutte sig til klyngen.

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

Den foregående kommando skal kopieres og opbevares til efterfølgende brug på arbejderknudepunkter.

Figur 7: Kubernetes master initialiseret

Som standard kan masterknuderne ikke planlægges og laves ved at bruge den "dedikerede" farve. Masterknudepunktet kunne gøres skemalagt med følgende kommando:

kubectl taint nodes --all dedicated-

kubeadm kommandoen understøtter nogle andre muligheder (se tabel 2), som vi ikke behøvede at bruge, men som kunne bruges til at tilsidesætte standardkommandoen.

Tabel 2: Kubeadm kommandoindstillinger

Installation af Calico Pod-netværket

For at Pods skal kunne kommunikere med hinanden, skal der installeres en Pod-netværksadd-on. Calico leverer en kubeadm-hostet installationskonfiguration i form af et ConfigMap på http://docs.projectcalico.org/master/getting-started/kubernetes/installation/hosted/kubeadm/calico.yaml, som vi skal bruge i dette afsnit til at installere et Pod-netværk. Kør følgende kommando på masternoden for at installere Pod-netværket:

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

Alternativt kan du downloade calico.yaml og kopier til masternoden:

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

Kør derefter følgende kommando:

kubectl apply -f calico.yaml

Calico og en enkelt node etcd cluster bliver installeret, som vist i figur 8.

Figur 8: Installerer Calico Policy

Lister derefter alle Pods i alle Kubernetes-navneområder.

kubectl get pods --all-namespaces

kube-dns Pod'en skal køre, som vist i figur 9.

Figur 9: Liste Pods i alle navneområder

Sammenslutning af noder til klyngen

I dette afsnit vil vi forbinde arbejderknudepunkter til klyngen ved at bruge kubeadm-forbindelsen kommando, som har følgende syntaks:

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

Eventuelt kan kubeadm join kommandoen kan køres med --skip-preflight-checks mulighed for at springe den foreløbige validering over.

kubeadm join kommandoen bruger det medfølgende token til at kommunikere med API-serveren og hente rod-CA-certifikatet og opretter et lokalt nøglepar. Efterfølgende sendes en anmodning om certifikatsignering (CSR) til API-serveren til signering, og den lokale kubelet er konfigureret til at oprette forbindelse til API-serveren.

Kør kubeadm join kommando kopieret fra outputtet af kubeadm init kommando på hver af de Ubuntu-maskiner, der skal slutte sig til klyngen.

Først skal du logge SSH på Ubuntu-forekomsten/-erne:

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

og

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

Kør derefter kubeadm join kommando. Først udføres nogle kontroller før flyvningen. Det angivne token er valideret. Dernæst bruges node discovery. Der oprettes en klyngeinfoopdagelsesklient, og der anmodes om oplysninger fra API-serveren. Et klyngeinfoobjekt modtages, og en signatur verificeres ved at bruge det givne token. Klyngeinformationssignaturen og indholdet er fundet gyldigt, og nodeopdagelsen er fuldført. Efterfølgende udføres node bootstrapping, hvor API-endepunkterne https://10.0.0.129:6443 bruges til at etablere en forbindelse. Efterfølgende laves en certifikatsigneringsanmodning (csr) ved at bruge en API-klient til at få et unikt certifikat til noden. Når et signeret certifikat er modtaget fra API-serveren, genereres en kubelet-konfigurationsfil. Meddelelsen "Node join complete" angivet i figur 10 angiver, at noden har sluttet sig til klyngen.

Figur 10: Sammenføjning af en node til klyngen

På samme måde skal du køre den samme kommando på den anden Ubuntu-maskine. Den anden knude slutter sig også til klyngen, som angivet af outputtet i figur 11.

Figur 11: Forener anden node til klynge

Kør følgende kommando på masterknuden for at vise noderne:

kubectl get nodes

Masterknudepunktet og de to arbejderknudepunkter skal vises på listen, som vist i figur 12.

Figur 12: Visning af Kubernetes-klyndeknuder

Installation af en prøveapplikation

Dernæst skal vi teste klyngen. Kør følgende kommando for at køre en nginx -baseret Pod-klynge bestående af tre replikaer:

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

Liste over implementeringerne:

kubectl get deployments

List de klyngeomfattende Pods:

kubectl get pods -o wide

Vis implementeringen som en tjeneste af typen LoadBalancer :

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

Liste over tjenesterne:

kubectl get services

Outputtet fra de foregående kommandoer indikerer nginx implementering blev oprettet, og de tre Pods kører på tværs af de to arbejderknudepunkter i klyngen. En tjeneste kaldet "nginx" bliver også oprettet, som vist i figur 13.

Figur 13: Kørsel af en nginx Pod-klynge

Kopiér tjenestens klynge-IP. Kør curl-kommandoen for at starte tjenesten:

curl 10.0.0.99

HTML-markeringen fra tjenesten får output, som vist i figur 14.

Figur 14: Påkalder nginx-tjenesten

Afinstallation af klyngen

For at afinstallere klyngen installeret af kubeadm skal du køre følgende kommando:

kubeadm reset

Klyngen afinstalleres, som vist i figur 15.

Figur 15: Afinstallerer/nulstiller Kubernetes-klyngen

Begrænsninger

kubeadm har flere begrænsninger og anbefales kun til udviklingsbrug. Begrænsningerne for kubeadm er som følger;

• Kun få operativsystemer understøttes:Ubuntu 16.04+, CentOS 7, HypriotOS v1.0.1+.
• Ikke egnet til produktionsbrug.
• Integration af skyudbydere er eksperimentel.
• Der oprettes en klynge med kun en enkelt master med en enkelt etcd-database. Høj tilgængelighed understøttes ikke, hvilket betyder, at masteren er et enkelt fejlpunkt (SPOF).
• HostPort- og HostIP-funktionalitet understøttes ikke.
• Nogle andre kendte problemer, når kubeadm bruges med RHEL/CentOS 7 og VirtualBox.

Yderligere udviklinger i kubeadm

kubeadm er i alfa i Kubernetes v 1.5 og er i beta siden Kubernetes 1.6. Mindre rettelser og forbedringer af kubeadm fortsætter med hver ny Kubernetes-version:

• Med Kubernetes 1.7 overskrives ændringer af klynge interne ressourcer installeret med kubeadm ved opgradering fra v 1.6 til v 1.7.
• I Kubernetes 1.8 er standard Bootstrap-token oprettet med kubeadm init bliver ugyldig og slettes efter 24 timer efter oprettelsen for at begrænse eksponeringen af ​​den værdifulde legitimation. kubeadm join kommandoen uddelegerer TLS bootstrapping til kubelet iteslf i stedet for at genimplementere processen. Bootstrappen KubeConfig filen er skrevet til /etc/kubernetes/bootstrap-kubelet-conf med kubeadm join .

Konklusion

I denne artikel brugte vi kubeadm-værktøjsfunktionen, der var tilgængelig siden Kubernetes v1.4 til at starte en Kubernetes-klynge. Først installeres de nødvendige binære filer til Docker, kubectl, kubelet og kubeadm. Efterfølgende, kubeadm init kommandoen bruges til at initialisere masterknuden i klyngen. Til sidst, kubeadm join kommandoen bruges til at forbinde arbejdernoder med klyngen. Et eksempel på nginx applikationen køres for at teste klyngen.