Portal - .easec

Arbeta med bestående lagring i Kubernetes

När jag har läst dokumentationen från Kubernetes, så har det varit lite svårt att förstå hur detta konfigureras. Så det är väl lika bra att gå igenom detta steg för steg.

Övergripande steg

1. Konfigurera lagring.
2. Skapa .yaml-fil för lagring  (ansvaret ligger på Ops). 
3. Skapa .yaml-fil för begäran (eng. claim) (ansvaret ligger på Dev).
4. Skapa .yaml-fil för pod som för lagringsdelen refererar til claim (ansvaret ligger på Dev).
5. Starta pod.

Beroende lite på funktionalitet kan storageClass behöva konfigureras. I mitt kursmaterial finns detta beskrivet dels i det teoretiska materialet, men även i en övning där lokal lagring skall användas. 

Steg 1. Konfigurera lagring

Detta beror på vilken typ av lagring som skall användas. I mina övningsexempel används både lokal lagring på nod (easec-linux2) och på NFS-server. Båda dessa kommer att behöva konfigureras. Kubernetes kan arbeta med en mängd olika typer av lagring och som finns både lokalt och i molntjänst.

Exemplet i denna blogg kommer att använda NFS-server. För att underlätta lite i kurs- och labbsammanhang har .easec tagit fram en docker-container för detta syfte. Dockerfile för denna container finns här: https://github.com/easec/nfs-server . I andra sammanhang är det alltid bäst att sätta upp en "riktig" NFS-server.

Förutsättningar: Docker installerat och Kubernetes uppsatt enligt .easec:s specifikationer. git installerat liksom nfs-utils  (på Ubuntu: sudo apt-get install nfs-kernel-server) på alla ingående maskiner.

På https://github.com/easec/Kubernetes finns alla .yaml-filer som refereras, klona dessa till din hemmakatalog med kommandot git clone https://github.com/easec/Kubernetes.git .

1. Öppna terminalfönstret och skriv in följande kommando och klicka på Enter efter varje rad:

    docker run -d --net=host \ 

    --privileged --name nfs-server \

    easec/nfs-server \

    /exports/data-0001 /exports/data-0002

    Container kommer att exponera två stycken kataloger, /exports/data-0001 och /exports/data-0002.

Steg 2: Skapa .yaml-fil för lagring (pv)

1. Om du har klonat mitt arkiv, förflytta dig till katalogen Kubernetes/persistent-volumes.

2. Öppna filen nfs-0001.yaml i din editor.

Lägg märke till att kapacitet anges under spec:, accessModes anger typ av access, i mitt kursmaterial har jag beskrivit de olika typerna av access som finns. På ett liknande sätt finns det även beskrivit de olika typerna av persistentVolumeReclaimPolicy som finns. Under nfs: anges anslutningsinformation till den maskin där docker-container med NFS-server körs och i detta fallet den första katalogen.

3. Applicera denna .yaml-fil med kommandot: kubectl create -f nfs-0001.yaml .

4. Öppna filen nfs-0002.yaml i din editor.

Denna .yaml-fil liknar den första, med två undantag. Det första undantaget är kapaciteten (i den första var den satt till 2Gi) som är satt till 5Gi och det andra undantaget är referens till katalog och i detta fallet pekar denna på den andra katalogen som exponeras av NFS-server.

5. Applicera denna .yaml-fil med kommandot: kubectl create -f nfs-0002.yaml .

6. För att se alla PersistentVolumes i klustret, använd kommandot kubectl get pv .

 

Steg 3: Skapa .yaml-fil för claim (pvc)

1. Öppna filen pvc-mysql.yaml i din editor.

Denna fil beskriver vad som begärs av eventuell pod som kopplas mot denna claim. I detta fallet kommer det att krävas att lagringen har möjlighet att exponera 3Gi. Går du tillbaks lite i denna bloggtext, så ser du att det är bara pv mot nfs-0002 som har denna kapacitet.

2. Applicera denna .yaml-fil med kommandot: kubectl create -f pvc-mysql.yaml .

3. Öppna filen pvc-http.yaml i din editor.

Precis som tidigare fil (pvc-mysql.yaml) beskriver denna vad som begärs av eventuell pod som kopplas mot denna claim. I detta fallet kommer det att krävas att lagringen har möjlighet att exponera 1Gi.

4. Applicera denna .yaml-fil med kommandot: kubectl create -f pvc-http.yaml .

5. För att se alla claims i klustret, använd kommandot kubectl get pvc . När du har kört kommandot, kommer du att se att claim-http är associerat med nfs-0001 och claim-mysql är associerat med nfs-0002. Du kan även se den totala kapaciteten för respektive lagring.

Steg 4: Skapa .yaml-fil för pods

1. Öppna filen pod-mysql.yaml i din editor. 

Under sektionen containers kan du se att pod kommer att baseras på avspeglingen openshift/mysql-55-centos7, ett antal miljövariabler är definierade (i produktion används exempelvis Secrets för detta), monterar volym till katalogen /var/lib/mysql/data. Under sektionen volumes finns referens till claim-mysql.

2. Öppna filen pod-http.yaml i din editor. 

Under sektionen containers kan du se att pod kommer att baseras på avspeglingen nginx:alpine, port 80 kommer att exponeras, monterar volym till katalogen /usr/share/nginx/html. Under sektionen volumes finns referens till claim-http.

Steg 5: Starta pods

1. Starta pod-mysql med kommandot: kubectl create -f pod-mysql.yaml . Vi kommer inte att använda denna, annat än för att se att den plockar "rätt" lagring utifrån claim.

2. Starta pod-http med kommandot: kubectl create -f pod-http.yaml .

3. Använd kommandot kubectl get pods för att verifiera att dessa körs. Tänk på om du inte installerade nfs-utils (på Ubuntu: sudo apt-get install nfs-kernel-server) på noderna, kommer någon pod att stå läget att den skapas under längre tid. För att se vad som händer, kan du använda kommandot kubectl describe pod <namnet_på_denna_pod>, troligtvis har du ett felmeddelande att volym inte kan monteras. Installera nfs-utils och strax kommer du att se att pod är i läget Ready,

Extra: verifiera funktion

1. Anslut till docker-container nfs-server och skapa index.html, använd kommandot:  docker exec -it nfs-server bash -c "echo '<h1> The end is near</h1>You are not getting any younger and neither are your forms.' > /exports/data-0001/index.html" . Om du vill ansluta till pod kan du använda kommandot kubectl exec -it <namn_på_pod> bash .

2. Ta reda på IP-adress för pod, genom att använda följande kommando: ip=$(kubectl get pod www -o yaml | grep podIP | awk '{split($0,a,":"); print a[2]}'); echo $ip .

3. Verifiera med kommandot curl $ip att texten du skrev in under punkt 1 visas.

4. Om du har webbläsare, kan du ansluta denna till pod och texten du skrev in under punkt  1 visas.

I .easec:s kurs arbetar du vidare med dessa pods.

Rensa

Använd stegen nedan för att rensa din miljö!

1. Använd kommandot kubectl delete pod www mysql för att plocka bort pods.

2. Använd kommandot kubectl delete pvc claim-http claim-mysql för att plocka bort pvc.

3. Använd kommandot kubectl delete pv nfs-0001 nfs-0002 för att plocka bort pv.

4. Använd kommandot docker stop nfs-server && docker rm nfs-server för att stänga ner docker-container och plocka bort denna.

Tidig dator ålder

På 60-talet var det inte så vanligt med datorer, då kostnaden för dessa var väldigt höga. Bara för att hyra en dator var kostnaden alldeles för höga för att de skulle vara vanliga för de flesta företagen.

Ett behov och att lösa detta behov är en drivkraft för utveckling, så också inom datorvärlden. De tidigaste datorerna vara dedicerade för en specifik arbetsuppgift och det kunde ta dagar, t om veckor att köra ett jobb. Detta ledde fram till utvecklingen av virtualisering. Utvecklingen leddes av tanken att kunna dela dators resurser  med många användare på samma gång.

När skapandet av centraliserad dator kom, så var detta de första tecknen på virtualisering. Under 60-talet var flera terminal ansluten till en större central dator vilket möjliggjorde att arbetet kunde utföras från en central plats. Att arbeta med en central plats för dator, gav möjlighet att från denna plats kontrollera all bearbetning från en central plats, om en terminal skulle sluta att fungera, kunde användare gå till en annan terminal och logga på denna för att fortsätta sitt arbete. Dock fanns det fortfarande några negativa sidor. Exempelvis om användare kraschade den centrala datorn, så gick systemet ner för alla användare. Detta ledde fram till datorer inte bara behöver kunna separera användare utan även processer som körs i systemet.

Virtualisering

1973 publicerade Gerald J. Popek och Robert P. Goldberg rapporten Formal Requirements for Virtualizable Third Generation Architectures, där de beskriver tre typer av virtualisering:

-         Type 0, där virtualisering görs direkt på hårdvara.

-         Type 1, där virtualiseringstekniken innehåller ett operativsystem.

-         Type 2, där virtualiseringstekniken kräver att det redan finns ett operativsystem.

Detta dokument ligger till grund för all virtualisering som företag och organisationer arbetar med idag och blir också, kan man säga, en delning mellan virtualisering och teknik för att särskilja applikationer eller tjänster.

chroot

1979 togs det ett annat steg med utvecklingen av kommandot chroot (change root). chroot används för att skapa en delad men isolerad miljö. Kommandot ger en möjlighet till att ändra root-miljö för en körandes process tillsammans med dess barn (children).

Detta gav en möjlighet att isolera systemprocesser till egna segregerade filsystem så att tester kunde utföras utan att påverka den globala miljön för systemet. I mars 1982 la Bill Joy till kommandot i den sjunde versionen av Unix.

Solaris Zones

2004 lanserades Solaris containers, Solaris containers skapar en full miljö för applikationen genom att använda Solaris Zones. Med zones får applikationen tillgång till användare, processer, filsystem och hårdvara på systemet. Dock kan applikationen bara se var som finns i sin egen zon.

jail

I syftet att förstå containers, får vi förflyttas oss framåt i tiden lite, till 1990-talet, när Bill Cheswick arbetade med att försöka förstå hur en cracker använde den tid som denna hade på sig i ett system. I sin undersökning byggde Cheswick en miljö som tillätt honom att analysera cracker:s tangentnedslagningar och för att lära sig dennes teknik. Hans lösning var att använda en miljö skapade av chroot och som var modifierad. Resultatet av Cheswick:s studier ledde fram till kommandon jail i Linux.

I mars 2000 (närmare bestämt 4 mars 2000), introducerade FreeBSD kommandot jail i sitt operativsystem. Även om kommandot liknande chroot så inkluderades ytterligare funktioner såsom möjlighet att isolera filsystem, användare, nätverk, etc. FreeBSD jail ger möjlighet till att tilldela IP-adress, konfigurera skräddarsydda mjukvaruinstallation och modifiering för varje miljö. Dock till en kostnad då funktionalitet för mjukvaran påverkades.

control groups (cgroups)

2006 lanserade ett antal utvecklare på Google process containers. Dessa var designade för isolering och begränsningar för resurnyttjande för process. 2007 döptes process container om till control groups (cgroups) för att undvika namnkollision med ordet containers.

LXC

2008 lades cgroups till i Linux kernel 2.6.24 och som i sin tur ledde till att projektet LXC startades. LXC står för Linux Containers och ger en möjlighet till virtualisering på operativsystemsnivå, genom att tillåta att ett antal isolerade Linuxbaserade miljöer (containers) körs på delad Linux kernel. En och var av dessa containers har sina egna processer och nätverk.

LMTCFY

2013 ändrade Google på konceptet containers, genom att göra sitt projekt Let Me Contain That For You (LMTCFY) till ett öppet projekt. Genom att använda LMTCFY, kunde applikationer skrivas för container och med möjlighet att skapa och hantera sina egna undercontainers. Arbetet på LMCTFY stoppades 2015 och Google beslöt att arbetet skulle läggas i projektet libcontainer, som Docker hade startat.

 

Start för Docker

"The technology was not accessible/useful for developers, containers were not portable between different environments, and there was no ecosystem or set of standard containers," Docker's chief executive Ben Golub.

Docker lanserades som ett open-source projekt 2013. Docker tillhandarhåller möjligheten att paketera containers så att de kan flyttas från en miljö till en annan. Från början använda Docker LXC-teknologien, men 2014 ersattes LXC med libcontainer, vilket ger en möjlighet för container att arbeta med Linux namespaces, libcontainer control groups, capabilities, säkerhetsprofiler i AppArmor, gränssnitt för nätverk och regelverk för brandvägg. Docker bidrar till community med globalt eller lokalt förråd kallat för registry, ett restful API och CLI-klient. Senare har även Docker implementerat hanteringssystem för kluster med namnet Docker Swarm och ett antal andra produkter för orkestrering.

.easec har ett stort antal kurser där du får lära dig allt om Docker och containers, se gärna vidare på https://portal.easec.se/moodle/course/index.php?categoryid=7