Linux gevorderd

Linux gevorderd

Les 0: Basisconfiguratie Ubuntu-server

Maak een standaard Linux-server met de volgende instellingen.

  • apt update
  • apt install net-tools
  • Gebruiker (student) met sudo rechten
  • Basis firewall instellingen
  • SSH toevoegen aan UFW
  • SSH-sleutels delen met je server
  • Standaard gebruiker moet met SSH in kunnen loggen op de server

Zie hiervoor les 0 van de Wiki Linux-server.

https://maken.wikiwijs.nl/171453/Linux_server

Les 1: Docker

Docker is een applicatie die het proces van het beheren van applicatieprocessen in containers vereenvoudigt. Met containers kun je applicaties uitvoeren in processen die zijn gescheiden van bronnen. Ze lijken op virtuele machines, maar containers zijn draagbaarder, resourcevriendelijker en afhankelijker van het hostbesturingssysteem.

In deze les installeer en gebruik je Docker Community Edition (CE) op Ubuntu 20.04. Je installeert Docker zelf, werkt met containers en images.

Docker installeren

Het Docker-installatiepakket dat beschikbaar is in de officiële Ubuntu-repository is mogelijk niet de nieuwste versie. Om ervoor te zorgen dat we de nieuwste versie krijgen, installeren we Docker vanuit de officiële Docker-repository. Om dat te doen, voegen we een nieuwe pakketbron toe, voegen we de GPG-sleutel van Docker toe om ervoor te zorgen dat de downloads geldig zijn, en installeren we vervolgens het pakket.

Werk eerst je bestaande lijst met pakketten bij:

sudo apt update

Installeer vervolgens een paar vereiste pakketten waarmee aptje pakketten via HTTPS kunt gebruiken:

sudo apt install apt-transport-https ca-certificates curl software-properties-common

Voeg vervolgens de GPG-sleutel voor de officiële Docker-repository toe aan je systeem:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

Voeg de Docker-repository toe aan APT-bronnen:

sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu focal stable"

Werk vervolgens de pakketdatabase bij met de Docker-pakketten uit de nieuw toegevoegde opslagplaats:

sudo apt update

Zorg ervoor dat je op het punt staat te installeren vanuit de Docker-opslagplaats in plaats van de standaard Ubuntu-opslagplaats:

apt-cache policy docker-ce

Je ziet de uitvoer als volgt, hoewel het versienummer voor Docker kan verschillen:

Uitvoer van apt-cache policy docker-ce:

docker-ce:
  Installed: (none)
  Candidate: 5:20.10.3~3-0~ubuntu-focal
  Version table:
     5:20.10.3~3-0~ubuntu-focal 500
        500 https://download.docker.com/linux/ubuntu focal/stable amd64 Packages

Merk op dat het docker-ceniet is geïnstalleerd, maar de kandidaat voor installatie komt uit de Docker-repository voor Ubuntu 20.04 ( focal).

Installeer ten slotte Docker:

sudo apt install docker-ce

Docker zou nu moeten worden geïnstalleerd, de daemon zou moeten zijn gestart en het proces zou moeten starten bij het opstarten. Controleer of het werkt:

sudo systemctl status docker

De uitvoer moet er ongeveer als volgt uitzien, om aan te geven dat de service actief is:

Als je Docker nu installeert, krijg je niet alleen de Docker-service (daemon) maar ook het dockeropdrachtregelprogramma of de Docker-client. 

Docker uitvoeren zonder sudo

Standaard kan de dockeropdracht alleen worden uitgevoerd door de rootgebruiker of door een gebruiker in de docker- groep, die automatisch wordt aangemaakt tijdens het installatieproces van Docker. Als je probeert om de dockeropdracht uit te voeren zonder er een voorvoegsel aan te geven, met sudoof zonder in de docker- groep te zijn, krijg je een output als deze:

docker: Cannot connect to the Docker daemon. Is the docker daemon running on this host?. See 'docker run --help'.

Als je niet sudowilt typen wanneer je de dockeropdracht uitvoert, voeg je de gebruikersnaam toe aan de dockergroep:

sudo usermod -aG docker ${USER}

Om het nieuwe groepslidmaatschap toe te passen, log je uit bij de server en weer in, of typ je het volgende:

su - ${USER}

Je wordt gevraagd om je gebruikerswachtwoord in te voeren om door te gaan.

Bevestig dat uw gebruiker nu is toegevoegd aan de docker- groep door te typen:

id -nG 
Output
student sudo docker

Als je een gebruiker moet toevoegen aan de dockergroep waarbij je niet bent aangemeld, geef die gebruikersnaam dan expliciet op met:

sudo usermod -aG docker username

In de rest van deze les wordt ervan uitgegaan dat je de dockeropdracht uitvoert als gebruiker in de dockergroep . Als je ervoor kiest om dit niet te doen, plaats je de opdrachten vooraf met sudo.

Laten we het dockercommando onderzoeken .

Het docker commando gebruiken

Opdracht dockerbestaat uit het doorgeven van een reeks opties en opdrachten gevolgd door argumenten. De syntaxis heeft deze vorm:

docker [option] [command] [arguments]

Om alle beschikbare subopdrachten te zien, typ je:

docker

Vanaf Docker 19 bevat de volledige lijst met beschikbare subopdrachten

Om de beschikbare opties voor een specifieke opdracht te zien, typ je:

docker docker-subcommand --help

Om systeembrede informatie over Docker te bekijken, gebruik je:

docker info

Laten we enkele van deze commando's onderzoeken. We beginnen met het werken met Docker images.

Werken met Docker-images

Docker-containers worden gemaakt op basis van Docker-installatie kopieën. Docker haalt deze images standaard uit Docker Hub, een Docker-registry beheerd door Docker, het bedrijf achter het Docker-project. Iedereen kan zijn Docker-images hosten op Docker Hub, dus voor de meeste applicaties en Linux-distributies die je nodig hebt, worden daar images gehost.

Om te controleren of je images kunt openen en downloaden van Docker Hub, typ je:

docker run hello-world

De uitvoer geeft aan dat Docker correct werkt:

Output
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
0e03bdcc26d7: Pull complete 
Digest: sha256:95ddb6c31407e84e91a986b004aee40975cb0bda14b5949f6faac5d2deadb4b9
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

Docker kon de hello-worldimage aanvankelijk niet lokaal vinden, dus heeft het de afbeelding gedownload van Docker Hub, de standaardrepository. Nadat de afbeelding was gedownload, heeft Docker een container gemaakt van de afbeelding en de applicatie binnen de container uitgevoerd, waarbij het bericht wordt weergegeven.

Je kunt zoeken naar images die beschikbaar zijn op Docker Hub door de dockeropdracht met de searchsubopdracht te gebruiken. Om bijvoorbeeld naar de Ubuntu-afbeelding te zoeken, typ je:

docker search ubuntu

Het script crawlt door Docker Hub en retourneert een lijst met alle images waarvan de naam overeenkomt met de zoekreeks. In dit geval ziet de uitvoer er ongeveer zo uit:

Output
NAME                                                      DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
ubuntu                                                    Ubuntu is a Debian-based Linux operating sys…   11806     [OK]       
dorowu/ubuntu-desktop-lxde-vnc                            Docker image to provide HTML5 VNC interface …   497                  [OK]
websphere-liberty                                         WebSphere Liberty multi-architecture images …   267       [OK]       
rastasheep/ubuntu-sshd                                    Dockerized SSH service, built on top of offi…   250                  [OK]
consol/ubuntu-xfce-vnc                                    Ubuntu container with "headless" VNC session…   232                  [OK]
ubuntu-upstart                                            Upstart is an event-based replacement for th…   110       [OK]       
neurodebian                                               NeuroDebian provides neuroscience research s…   79        [OK]       
1and1internet/ubuntu-16-nginx-php-phpmyadmin-mysql-5      ubuntu-16-nginx-php-phpmyadmin-mysql-5          50                   [OK]
ubuntu-debootstrap                                        debootstrap --variant=minbase --components=m…   44        [OK]       
open-liberty                                              Open Liberty multi-architecture images based…   42        [OK]       
i386/ubuntu                                               Ubuntu is a Debian-based Linux operating sys…   24                   
nuagebec/ubuntu                                           Simple always updated Ubuntu docker images w…   24                   [OK]
1and1internet/ubuntu-16-apache-php-5.6                    ubuntu-16-apache-php-5.6                        14                   [OK]

In de OFFICIËLE kolom geeft OK een afbeelding aan die is gebouwd en ondersteund door het bedrijf achter het project. Als je eenmaal de image hebt geïdentificeerd die je wilt gebruiken, kun je deze met de pullsubopdracht naar je computer downloaden .

Voer de volgende opdracht uit om de officiële ubuntuafbeelding naar je computer te downloaden :

docker pull ubuntu

Je ziet de volgende output:

Output
Using default tag: latest
latest: Pulling from library/ubuntu
83ee3a23efb7: Pull complete 
db98fc6f11f0: Pull complete 
f611acd52c6c: Pull complete 
Digest: sha256:703218c0465075f4425e58fac086e09e1de5c340b12976ab9eb8ad26615c3715
Status: Downloaded newer image for ubuntu:latest
docker.io/library/ubuntu:latest

Nadat een image is gedownload, kun je een container uitvoeren met behulp van de gedownloade image met het runsubcommando. Zoals je in het hello-worldvoorbeeld hebt gezien, zal de Docker-client eerst de image downloaden en vervolgens een container gebruiken als er geen image is gedownload wanneer deze dockerwordt uitgevoerd met het runsubcommando.

Om de image te zien die naar je computer zijn gedownload, typ je:

docker images

De uitvoer ziet er als volgt uit:

Output
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
ubuntu        latest    f63181f19b2f   3 weeks ago     72.9MB
hello-world   latest    bf756fb1ae65   13 months ago   13.3kB

Zoals je later in deze les zult zien, kunnen images die je gebruikt om containers uit te voeren, worden gewijzigd en gebruikt om nieuwe images te genereren, die vervolgens kunnen worden geüpload (pushed is de technische term) naar Docker Hub of andere Docker-registers.

Laten we eens kijken hoe je containers in meer detail kunt uitvoeren.

Een Docker-container uitvoeren

De hello-worldcontainer die je in de vorige stap hebt uitgevoerd, is een voorbeeld van een container die wordt uitgevoerd en afgesloten na het verzenden van een testbericht. Containers kunnen veel nuttiger zijn dan dat, en ze kunnen interactief zijn. Ze lijken tenslotte op virtuele machines, maar zijn resource-vriendelijker.

Laten we als voorbeeld een container uitvoeren met de nieuwste image van Ubuntu. De combinatie van de -i en -t schakelaars geeft je interactieve shell-toegang tot de container:

docker run -it ubuntu

Je opdrachtprompt zal veranderen om het feit weer te geven dat je nu in de container werkt en zou deze vorm moeten hebben:

Output
root@37bed2ed6698:/#

Let op de container-ID in de opdrachtprompt. In dit voorbeeld is het 37bed2ed6698. Je hebt die container-ID later nodig om de container te identificeren wanneer je deze wilt verwijderen.

Nu kun je elke opdracht in de container uitvoeren. Laten we bijvoorbeeld de pakketdatabase in de container bijwerken. Je hoeft geen sudocommando voor te voegen, omdat je in de container werkt als de rootgebruiker :

apt update

Installeer vervolgens een applicatie erin. Laten we Node.js installeren:

apt install nodejs

Dit installeert Node.js in de container vanuit de officiële Ubuntu-repository. Als de installatie is voltooid, controleert je of Node.js is geïnstalleerd:

node -v

Je ziet het versienummer weergegeven in je terminal:

Output
v10.19.0

Alle wijzigingen die je in de container aanbrengt, zijn alleen van toepassing op die container.

Typ exitin de prompt om de container te verlaten .

Laten we nu eens kijken naar het beheren van de containers op ons systeem.

Docker-containers beheren

Nadat je Docker een tijdje hebt gebruikt, heb je veel actieve (actieve) en inactieve containers op je computer. Om de actieve te zien, gebruik:

docker ps

U ziet een output die lijkt op de volgende:

Output
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES

In deze les heb je twee containers gestart; een uit de hello-worldimage en een andere uit de ubuntuimage. Beide containers zijn niet meer actief, maar ze staan ​​nog steeds op je systeem.

Om alle containers te zien - actief en inactief, voer je uit docker ps met de -aoptie:

docker ps -a

U ziet de output vergelijkbaar met deze:

CONTAINER ID   IMAGE         COMMAND       CREATED          STATUS                      PORTS     NAMES
37bed2ed6698   ubuntu        "/bin/bash"   9 minutes ago    Exited (0) 3 minutes ago              exciting_nash
8af29b12b9cb   hello-world   "/hello"      20 minutes ago   Exited (0) 20 minutes ago             vibrant_kowalevski

Om de laatste container die je hebt gemaakt te bekijken, geeft je deze de -loptie:

docker ps -l 
CONTAINER ID   IMAGE     COMMAND       CREATED          STATUS                     PORTS     NAMES
37bed2ed6698   ubuntu    "/bin/bash"   11 minutes ago   Exited (0) 5 minutes ago             exciting_nash

Om een ​​gestopte container te starten, gebruikt je docker start, gevolgd door de container-ID of de naam van de container. Laten we de op Ubuntu gebaseerde container starten met de ID 37bed2ed6698:

docker start 37bed2ed6698

De container wordt gestart en je kunt docker psgebruiker om de status te zien:

Output
CONTAINER ID   IMAGE     COMMAND       CREATED          STATUS          PORTS     NAMES
37bed2ed6698   ubuntu    "/bin/bash"   13 minutes ago   Up 25 seconds             exciting_nash

Gebruik docker stop, gevolgd door de container-ID of -naam om een ​​actieve container te stoppen . Deze keer gebruiken we de naam die Docker aan de container heeft toegewezen, namelijk exciting_nash:

docker stop exciting_nash

Als je eenmaal hebt besloten dat je een container niet langer nodig hebt, verwijder je deze met de docker rmopdracht, opnieuw met behulp van de container-ID of de naam. Gebruik de docker ps -aopdracht om de container-ID of naam te zoeken voor de container die aan de hello-worldafbeelding is gekoppeld en deze te verwijderen.

docker rm vibrant_kowalevski

Je kunt een nieuwe container starten en deze een naam geven met de --nameoptie. Je kunt de --rmschakelaar ook gebruiken om een ​​container te maken die zichzelf verwijdert wanneer deze wordt gestopt. Ziedocker run helpopdracht voor meer informatie over deze en andere opties.

Je weet nu hoe je moet zoeken naar images, deze naar de computer download en deze start/stopt. Daarna ben je in staat de container die niet meer draait te verwijderen.

Opdracht Docker

De opdracht voor deze les staat op ItsLearning. Deze gaat over het installeren van Docker-ce, het starten en stoppen van containers en het zoeken naar images.

Les 2: Containers

Docker-container maken met Dockerfile

Zodra we een proces in Docker starten vanuit een image, haalt Docker de image en de bijbehorende bovenliggende images op en herhaalt het proces totdat het de basis-image heeft bereikt. Vervolgens voegt het Union File System een ​​lees-schrijflaag toe. Die lees-schrijflaag, de informatie over de bovenliggende image en andere informatie zoals de unieke id, netwerkconfiguratie en resourcelimieten wordt een container genoemd. Containers hebben statussen omdat ze kunnen veranderen van actieve naar verlaten status. Een container met de status 'running' bevat een boom van processen die op de CPU worden uitgevoerd, geïsoleerd van de andere processen die op de host worden uitgevoerd, waarbij de status van het bestandssysteem wordt afgesloten en de exitwaarde behouden blijft. Je kunt er een container mee starten, stoppen en herstarten.

Een Dockerfile is een script/tekstbestand, samengesteld uit verschillende commando's en argumenten die achtereenvolgens worden opgesomd om automatisch acties uit te voeren op een basisimage om een ​​nieuwe te creëren. Het helpt ons om te voorkomen dat er problemen onstaan tijdens het uitvoeren van container. Ze worden gebruikt om dingen te organiseren en helpen enorm bij implementaties door het proces van begin tot eind te vereenvoudigen. Het begint met het definiëren van een afbeelding FROM waaruit het bouwproces begint en levert een nieuwe afbeelding met vereiste opdrachten en argumenten die moeten worden gebruikt voor het maken van docker-containers.

Hier zijn dus een snelle en eenvoudige stappen over hoe we een Dockerfile kunnen gebruiken om een ​​Docker-container te maken.

Docker-commands

Voordat we beginnen met het maken van onze Dockerfile, moeten we de nodige commando's leren om een ​​werkende Dockerfile te maken. Er zijn tientallen opdrachten die kunnen worden gebruikt om het te maken.

ADD

De opdracht ADD wordt gebruikt om de bestanden van een brondirectory naar de bestemming te kopiëren, de bron kan ook een url zijn. Als het een url is, zal de opdracht het doel eenvoudig naar de bestemmingsmap downloaden.

CMD

CMD-opdracht wordt gebruikt om specifieke opdrachten uit te voeren die worden uitgevoerd bij het maken van containers op basis van de afbeelding. Het lijkt erg op de RUN-opdracht, terwijl CMD niet wordt uitgevoerd tijdens het bouwen.

ENTRYPOINT

ENTRYPOINT-argument stelt de concrete standaardtoepassing in die wordt gebruikt elke keer dat een container wordt gemaakt met behulp van de afbeelding.

ENV

ENV wordt gebruikt om de omgevingsvariabelen in te stellen. Deze variabelen zijn toegankelijk met de docker-container die een enorme hoeveelheid flexibiliteit biedt voor het uitvoeren van programma's.

FROM

Het FROM-argument definieert het basisimage dat moet worden gebruikt om het bouwproces te starten. Dit kan elk docker-image zijn, of het nu op de host of in de repository is.

WORKDIR

De WORKDIR-instructie wordt gebruikt om in te stellen waar het commando gedefinieerd met CMD moet worden uitgevoerd.

RUN

RUN is de opdracht die wordt gebruikt om de docker-images te bouwen, wat een centraal uitvoerende richtlijn is voor de Dockerfiles.

MAINTAINER

MAINTAINER is de opdracht die niet wordt uitgevoerd maar de auteur aangeeft, en dus het auteurveld van de afbeeldingen instelt.

USER

De USER-instructie wordt gebruikt om de UID (of gebruikersnaam) in te stellen die de container moet uitvoeren op basis van de image die wordt gebouwd.

VOLUME

De VOLUME-opdracht wordt gebruikt om toegang vanuit je container tot een map op de hostcomputer mogelijk te maken.

EXPOSE

De opdracht EXPOSE wordt gebruikt om een ​​opgegeven poort te koppelen om netwerken mogelijk te maken tussen het actieve proces in de container en de host.

Een Dockerfile maken

Nadat we de nodige commando's hebben geleerd om onze vereiste container te bouwen, gaan we snel aan de slag met onze eerste eigen container. Hier maken we een Dockerfile om een ​​image te maken om de Nginx Web Server-container te installeren. Daarvoor moeten we een bestand met de naam Dockerfile maken met onze favoriete teksteditor.

$ sudo nano Dockerfile

Vervolgens willen we onze Docker-configuratie toevoegen die de opdrachten en argumenten voor de Nginx Web Server-container bevat.

#Base image
FROM ubuntu

#Lets install NGINX
RUN apt -y update && apt -y install nginx

#Lets copy the local index.html to /tmp
COPY index.html /tmp/index.html
COPY default /etc/nginx/sites-available/default

#lets expose port 80
EXPOSE 80/tcp

CMD /usr/sbin/nginx && tail -f /dev/null

Nadat we het bestand met de bovenstaande opdrachten hebben gemaakt, gaan we het bestand opslaan en afsluiten.

Bovenstaande Dockerfile verwijst naar een index.html, zorg dat de index.html bestaat in dezelfde directory.

<b>Copied From physical machine.</b>

<h1> Hello, How are you?</h1>

Maak ook een bestand genaamd default, hierin komen een aantal default instellingen voor Nginx.

server {
        listen 80 default_server;
        listen [::]:80 default_server;

        root /tmp;

        # Add index.php to the list if you are using PHP
        index index.html index.htm index.nginx-debian.html;

        server_name _;
        location / {
                # First attempt to serve request as file, then
                # as directory, then fall back to displaying a 404.
                try_files $uri $uri/ =404;
        }
}

De volgende bestanden zitten nu in de directory:

-rw-r--r-- 1 root    root     287 Feb 11 16:40 Dockerfile
-rw-r--r-- 1 root    root     452 Feb 11 16:36 default
-rw-r--r-- 1 root    root      69 Feb 11 16:36 index.html

Een image bouwen met Dockerfile

Nu we klaar zijn met het maken van ons Dockerfile voor de Nginx Web Server Container, zullen we nu eindelijk een image bouwen met deze Dockerfile. Om een image te maken, moeten we de volgende opdracht uitvoeren in onze directory.

docker build -t my_first_nginx .

Het bovenstaande commando zal een image bouwen met de naam my_first_nginx met behulp van het gemaakte Dockerfile.

Een Docker-container maken

Met behulp van de image die we zojuist hebben gemaakt, gaan we nu verder met de laatste stap van het maken van een container met daarin een Nginx Web Server-container, met een naam naar keuze. Hier is het nginx.

# docker run --name nginx -p 80:80 -d my_nginx

Ten slotte hebben we onze Nginx-container gemaakt en deze wordt doorgestuurd naar poort 80. Om te controleren of deze correct werkt, kunnen we docker ps gebruiken.

 

Data uitwisseling tussen Host & Container

Over het algemeen zijn Docker-containers kortstondig en worden ze net zo lang uitgevoerd als nodig is tot de opdracht die in de container is uitgevoert, te voltooien. Alle gegevens die in de container zijn gemaakt, zijn standaard alleen beschikbaar vanuit de container en alleen terwijl de container actief is.

Docker-volumes kunnen worden gebruikt om bestanden te delen tussen een hostsysteem en de Docker-container. Laten we bijvoorbeeld zeggen dat je de officiële Docker Nginx-image wilde gebruiken en een permanente kopie van de logbestanden van Nginx wilde bewaren om later te analyseren. Standaard nginxlogt in op de Docker-image in de /var/log/nginxmap in de Docker Nginx-container. Normaal gesproken is het niet bereikbaar vanaf het hostbestandssysteem.

In deze les onderzoeken we hoe je gegevens vanuit de container toegankelijk kunt maken op de hostcomputer.

Een volume koppelen

Met de volgende opdracht wordt een map gemaakt met de naam nginxlogsin de homedirectory van uw huidige gebruiker en wordt deze gekoppeld aan /var/log/nginxde container:

docker run --name=nginx -d -v ~/nginxlogs:/var/log/nginx -p 5000:80 nginx

Laten we even de tijd nemen om deze opdracht in detail te bekijken:

  • --name=nginx geeft de container een naam, zodat we er gemakkelijker naar kunnen verwijzen.
  • -dmaakt het proces los en voert het op de achtergrond uit. Anders zouden we alleen een lege Nginx-prompt bekijken en deze terminal niet kunnen gebruiken totdat we Nginx hebben gestopt.
  • -v ~/nginxlogs:/var/log/nginxzet een mount-volume op dat de /var/log/nginxdirectory vanuit de Nginx-container koppelt aan de ~/nginxlogsdirectory op de hostcomputer. Docker gebruikt een :om het hostpad te splitsen van het containerpad, en het hostpad komt altijd op de eerste plaats.
  • -p 5000:80stelt een poort in. De Nginx-container luistert 80standaard op poort . Deze optie wijst de poort 80van de container toe aan de poort 5000op het hostsysteem.
  • nginxspecificeert dat de container moet worden gebouwd op basis van de Nginx-afbeelding, die de opdracht geeft nginx -g "daemon off"om Nginx te starten.

Let op: De -voptie is erg flexibel. Het kan een volume binden of een naam geven met slechts een kleine aanpassing in de syntaxis. Als het eerste argument begint met een /of ~/, maakt je een mount. Verwijder dat, en je geeft het volume een naam.

  • -v /path:/path/in/containerkoppelt de host-directory /pathaan de/path/in/container
  • -v path:/path/in/containermaakt een volume met de naam pathzonder relatie met de host.

Toegang tot gegevens op de host

We hebben nu een kopie van Nginx die in een Docker-container op onze computer draait, en de poort van onze hostcomputer 5000verwijst rechtstreeks naar die kopie van de poort van Nginx 80.

Laad het adres in een webbrowser, met behulp van het IP-adres of de hostnaam van je server en het poortnummer : . Je zou Nginx moeten zien op:http://your_server_ip:5000

Interessanter is dat als we in de ~/nginxlogsdirectory op de host kijken, we zien dataccess.logis gemaakt door de container nginxdie ons verzoek zal tonen:

cat ~/nginxlogs/access.log

Dit zou iets moeten weergeven als:

Output
192.168.182.130 - - [11/Feb/2021:16:08:46 +0000] "GET / HTTP/1.1" 200 612 "-" "curl/7.68.0" "-"
192.168.182.128 - - [11/Feb/2021:16:10:54 +0000] "GET / HTTP/1.1" 200 612 "-" "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:85.0) Gecko/20100101 Firefox/85.0" "-"
192.168.182.128 - - [11/Feb/2021:16:10:54 +0000] "GET /favicon.ico HTTP/1.1" 404 153 "http://192.168.182.130/" "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:85.0) Gecko/20100101 Firefox/85.0" "-"
192.168.182.128 - - [11/Feb/2021:16:11:04 +0000] "GET / HTTP/1.1" 200 612 "-" "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:85.0) Gecko/20100101 Firefox/85.0" "-"
192.168.182.128 - - [11/Feb/2021:16:11:04 +0000] "GET /favicon.ico HTTP/1.1" 404 153 "http://192.168.182.130:5000/" "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:85.0) Gecko/20100101 Firefox/85.0" "-"

Als je wijzigingen in de ~/nginxlogsmap aanbrengt, kun je deze ook in realtime vanuit de Docker-container bekijken.

Les 3: Apache container

In deze les gaan we Apache in een container installeren en configureren.

Officiële Apache image
Deze link verwijst naar DockerHub.

Apache image maken

Voor het uitvoeren van Apache kunnen we de standaard image van DockerHub pullen, maar we kunnen ook onze eigen image bouwen. Hier kun je dan gelijk je eigen configuratie zetten en weet je zeker dat de container is ingesteld op de manier dat jij wilt.

Maken van je eigen image

Maak hiervoor een eigen directory 

mkdir apache

Maak nu met je favoriete editor een bestand met de naam Dockerfile

Hieronder een standaard opzet, waarbij de laatste versie van httpd(apache2) wordt gebruikt en er een html wordt geconfigureerd naar /usr/local/apache2/htdocs/ dit is de plek waar de container de index.html uit gaat hosten.

FROM httpd
COPY ./public-html/ /usr/local/apache2/htdocs/

Wil je een versie specificeren? zie hieronder:

FROM httpd:2.4
COPY ./public-html/ /usr/local/apache2/htdocs/

Zorg er dus voor dat er een een map public-html is gemaakt in de directory apache met daarin je index.html

Je eigen image bouwen

$ docker build -t my-apache2 .

Met de opdracht docker images kun je nu je eigen image zien

Je eigen container runnen

docker run -dit --name my-apache-app -p 80:80 my-apache2

Met bovenstaande opdracht is je container gestart.

  • -d Voer de container op de achtergrond uit en druk de container-ID af
  • -i Interactive, houd STDIN open, zelfs als deze niet is bevestigd
  • -t Wijs een pseudo-TTY toe
  • --name Geeft de container een naam
  • -p Publiceer de poort (en) van een container naar de host

Voor alle opties zie de officiële Docker documentatie

 

Docker run opties
Verwijzing naar de officiële documentatie

Container op een andere poort, bijvoorbeeld 8080

docker run -dit --name my-apache-app -p 8080:80 my-apache2

Bezoek nu het IP-adres van de server en zie dat je website online is en daarmee de container gestart.

Met docker ps of docker ps -a zie je alle gestarte containers.

Apache standaard image

Als je ervoor kiest de standaard image te gebruiken van Apache dan kun je op een paar manieren de container starten. Je kiest ervoor om eerst te zoeken naar de image en deze te pullen of je start de container en Docker pulled zelf de image en maakt gelijk de container. De stappen hieronder laten de verschillen zien.

Zoeken naar de officiële image

docker search httpd

Deze gezochte image ophalen naar de server

docker pull httpd

De container starten en je eigen index.html kopiëren

docker run -dit --name my-apache-app -p 80:80 -v /home/student/website/:/usr/local/apache2/htdocs/ httpd

Zorg er dus voor dat er een map is met je eigen index.html en verwijs hiernaar met een compleet pad.

Opties:

  • -d Voer de container op de achtergrond uit en druk de container-ID af
  • -i Interactive, houd STDIN open, zelfs als deze niet is bevestigd
  • -t Wijs een pseudo-TTY toe
  • --name Geeft de container een naam
  • -p Publiceer de poort (en) van een container naar de host
  • -v Binden van een volume

 

 

 

 

 

Docker opdrachten

Met de onderstaande opdrachten kunnen we de container starten, stoppen, verwijderen, enz.

Lijst van alle draaiende containers

docker ps

lijst van alle containers, ook de gestopte

docker ps -a

Lijst van alle images

docker images

Stoppen van je Apache container

docker stop my-apache-app

Starten van je Apache container

docker start my-apache-app

Updaten van je draaiende container (dit geval automatisch starten na reboot van je server)

docker update --restart=unless-stopped my-apache-app

Verwijderen van je container

docker rm my-apache-app

Verwijderen van je image

docker rmi my-apache-image

Docker systeem opschonen, alle niet gebruikte containers en images worden hiermee verwijderd

docker system prune

Bash shell in je container krijgen

docker exec -it my-apache-app /bin/bash

 

Opdracht

De opdracht voor de Apache container staat op ItsLearning. Goed kijken naar de naamgeving van de website, container, enz.

Les 4: MariaDB container

In deze les gaan we aan de slag met een database container. Er is gekozen voor de veel gebruikte MariaDB en haar laatste versie. We zullen kijken hoe je de container start/stopt, we gaan de container bewerken, de database aanmaken en aanpassen in de container zelf en via mysql-client. Daarna gaan we de container ook beschikbaar maken voor externe connecties.

Docker opdrachten

Met de onderstaande opdrachten kunnen we de container starten, stoppen, verwijderen, enz.

Lijst van alle draaiende containers

docker ps

lijst van alle containers, ook de gestopte

docker ps -a

Lijst van alle images

docker images

Stoppen van je Apache container

docker stop my-mariadb-app

Starten van je Apache container

docker start my-mariadb-app

Updaten van je draaiende container (dit geval automatisch starten na reboot van je server)

docker update --restart=unless-stopped my-mariadb-app

Verwijderen van je container

docker rm my-mariadb-app

Verwijderen van je image

docker rmi my-mariadb-image

Docker systeem opschonen, alle niet gebruikte containers en images worden hiermee verwijderd

docker system prune

Bash shell in je container krijgen

docker exec -it my-mariadb-app /bin/bash

MariaDB-container

Voor we gaan beginnen met containers te starten/stoppen en images te pullen gaan we kijken op Docker-hub wat de laatste stabiele versie is van MariaDB en welke we gaan gebruiken voor deze opdracht.

Op DockerHub zien we dat de versie 10.5.10 de stabiele geteste versie en dat 10.6 een Alpha versie is. We gebruiken in deze demo de latest tag en zullen daarmee 10.5.10 gebruiken.

Op de Docker-server gaan we zoeken naar MariaDB.

docker search mariadb

Daar zien we de volgende output:

NAME                                   DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
mariadb                                MariaDB Server is a high performing open sou…   4102      [OK]      

Hiermee zie je dat er veel verschillende versies zijn, wij gebruiken de mariadb.

Je kunt de image met de volgende opdracht naar je toe halen.

docker pull mariadb

De image staat nu lokaal op je server.

docker images

Je ziet nu welke images er lokaal staan.

Container starten

We gaan de container eerst lokaal starten, we zetten nog geen poorten open, daarmee zorg je ervoor dat je zelf de container beschikbaar hebt, maar van buiten er niemand bij kan.

Met de volgende opdracht start je de container.

docker run --name mariadbdemo -e MYSQL_ROOT_PASSWORD=password -d mariadb
  • --name = geeft de container een eigen naam
  • -e = enviroment, hiermee kun je variabelen instellen, in dit geval het wachtwoord voor de root MySQL gebruiker.
  • -d = detached, de container draait op de achtergrond.

De database container is hiermee gestart en kun je vinden onder docker-processes.

docker ps

Om het log bestand van je MariaBD container te zien kun je de volgende opdracht gebruiken.

docker logs mariadbdemo

Er draait nu nog geen database. Je kunt op 2 manieren inloggen, via de container of via mysql-client. Bij mysql-client moet je het IP-adres weten van de container, die Docker op de achtergrond aan deze container heeft gegeven. We gaan beide methodes demonstreren.

Inloggen via Docker exec

Een shell krijgen in je container.

docker exec -it mariadbdemo /bin/bash

Je ziet dat je nu al root in je container zit, nu kun je inloggen op mysql.

mysql -u root -p

Je zit na het invoeren van je wachtwoord op de MySQL-server dat draait in een container.

Inloggen via MySQL-client

Hiervoor moeten we op de server mysql-client installeren. Dat doe je met de volgende opdrachten.

sudo apt update

sudo apt install mysql-client -y

Hiermee wordt mysql-client geïnstalleerd.

Het enige wat mysql-client nodig heeft is een adres waar hij verbinding mee kan maken, hier zie je het verschil tussen MySQL lokaal draaien als service en in een containet draaien. Omdat mysql-client lokaal is geïnstalleerd kunnen we hem benaderen via het IP-adres dat Docker aan de container heeft gegeven. Remote kan (nog) niet.

Het vinden van het IP-adres van de container.

docker inspect mariadbdemo | grep IPAddress

"SecondaryIPAddresses": null,
            "IPAddress": "172.17.0.2",
                    "IPAddress": "172.17.0.2",

Verbinding maken met de MariaDB container.

mysql -u root -p -h 172.17.0.2

na het invullen van je wachtwoord zie je dat je nu gelijk in de MariaDB database zit.

 

Database maken

Voor welke manier je gekozen hebt om in de container te komen maakt niet uit, het maken van de database blijft hetzelfde. Laten we een test database maken, hieronder een voorbeeld. Kijk hiervoor goed naar je eigen opdracht, welke gebruiker moet je aanmaken? Wat is de naam van je database en tabellen? Welke kolommen moet je maken, enz.

Na het inloggen op je database, zie je als het goed is de volgende regel:

MariaDB [(none)]>

en kunnen we aan de slag gaan.

Welke databases zijn er?

SHOW DATABASES;

Gebruiker aanmaken

GRANT ALL PRIVILEGES ON *.* TO 'db_user'@'localhost' IDENTIFIED BY 'SuperSecretPassword1234#';
FLUSH PRIVILEGES;

Database maken

CREATE DATABASE db_noorderpoort;

Database gebruiken

USE db_noorderpoort;

Tabel maken in je database

CREATE TABLE Teachers (ID int, FirstName varchar(25), LastName varchar(25));

Tabel vullen

INSERT INTO Teachers (ID, FirstName, LastName) VALUES ('1', 'Patrick', 'Hulshof');

Tabel uitlezen

SELECT * FROM Teachers;

Met de volgende uitvoer:

+------+-----------+----------+
| ID   | FirstName | LastName |
+------+-----------+----------+
|    1 | Patrick   | Hulshof  |
+------+-----------+----------+

Externe toegang container

Om een container externe toegankelijk te maken moeten we de poorten voor toegang regelen met Docker. Met de -p optie kunnen we aangeven via welke poort de app beschikbaar wordt.

Laten we eerst kijken nu onze container voor intern gebruik draait of er al poorten open staan, want de standaard poort voor MySQL is 3306.

Met de standaard app in Linux ss (socket state) (vervanger voor netstat) kunnen we controleren of er geen poorten open staan voor deze container.

ss -altnp | grep 3306

Je ziet dat er geen uitvoer komt, daarmee concluderen we dat er nu geen applicaties draaien op poort 3306.

Laten we de container starten.

docker run --name mariadbdemoport -p 3306:3306 -e MYSQL_ROOT_PASSWORD=password -d mariadb

Je ziet dat de opdracht bijna identiek is aan de lokale MySQL container, maar dat er nu met -p wordt aangegeven welke poort en op de host met welke poort in de container verbonden wordt.

Controleren of de container draait.

docker ps

Je ziet nu 2 containers, waarvan 1 een poort op de host open heeft staan.

CONTAINER ID   IMAGE     COMMAND                  CREATED          STATUS          PORTS                    NAMES
c62de11d3907   mariadb   "docker-entrypoint.s…"   3 seconds ago    Up 2 seconds    0.0.0.0:3306->3306/tcp   mariadbdemoport
2e11bc5dcba4   mariadb   "docker-entrypoint.s…"   12 minutes ago   Up 12 minutes   3306/tcp                 mariadbdemo

Laten we nu eerst met ss controleren of er inderdaad een poort open staat op de host.

ss -altnp | grep 3306

Vanaf nu is de container extern beschikbaar en kan er verbinding mee gemaakt worden.

Als 3306 is toegevoegd aan UFW, dan kan er remote met de volgende opdracht verbinding worden gemaakt.

mysql -u root -p -h 192.168.182.128

Opruimen

Als je gereed bent met de containers, of je hebt ze niet meer nodig of je wilt ze verwijderen omdat ze een poort bezet houden.

Controleren welke containers er draaien.

docker ps -a

Container stoppen

docker stop mariadbdemo
docker stop mariadbdemoport

Containers verwijderen

docker rm mariadbdemo
docker rm mariadbdemoport

Image verwijderen

docker rmi mariadb

Als het goed is, is de lijst nu leeg als je docker ps -a uitvoert.

Opdracht

De opdracht voor MariaDB container staat op ItsLearning. Kijk goed welke namen je moet gebruiken in de databases, gebruikers en tabellen.

Les 5: PHP container

In deze les gaan we een LAMP Docker omgeving maken. Hiervoor hebben we voorgaande kennis nodig en gaan we de Apache aan de MariaDB container koppelen en een database op de website laten zien.

PHP container

Op DockerHub gaan we zoeken naar de PHP container. Dit is een reeds voorbereide container met PHP erin verwerkt en er is een variant gemaakt met Apache in de versie benoemd.

De laatste versie op het moment van maken van deze tutorial is php:8.0-apache.

Zoek dus zelf even goed op DockerHub naar de laatste versie van de PHP container en gebruik die dadelijk in je Dockerfile.

Maak een directory voor de php container.

mkdir php && cd php

Maak daarin een directory voor je website

mkdir website && cd website

In de directory website maak je een index.php

nano index.php

met daarin de volgende inhoud:

<?php 
phpinfo();
?>

Ga daarna een directory terug naar ~/php

Maak hier je Dockerfile

nano Dockerfile

Met de volgende inhoud:

FROM php:8.0-apache

COPY ./website/ /var/www/html/

Bouw nu je eigen image:

docker build -t my-php .

Controleer of je eigen image in de lijst staat

docker images

Run nu je eigen image op poort 80:

docker run --name my-php-app -p 80:80 -d my-php

Controleer met docker ps of er een container is gemaakt.

Ga naar het IP-adres van je server met een browser en zie daar de phpinfo. Kan zijn dat je poort 80 aan UFW moet toevoegen als deze actief is.

PHP verbinden met MariaDB container

Nu we de standaard PHP container hebben draaien en de phpinfo zichtbaar hebben op de website kunnen we een 2de image gaan maken en deze met een PDO verbinding de database ophalen uit de vorige les.

Zorg er dus voor dat de MariaDB container draait met daarin een test_db, ga na of deze draait en of er een database aanwezig is.

Met docker ps draaien er nu 2 containers:

CONTAINER ID   IMAGE        COMMAND                  CREATED          STATUS          PORTS                  NAMES
d77d71d759e1   my-php       "docker-php-entrypoi…"   46 minutes ago   Up 46 minutes   0.0.0.0:80->80/tcp     my-php-app
2e11bc5dcba4   mariadb      "docker-entrypoint.s…"   5 hours ago      Up 43 minutes   3306/tcp               mariadbdemo

Het is dus zaak dat er een interne MariaDB draait, met geen poorten open op de host server.

We gaan een nieuwe image maken voor de php met pdo verbinding. Maak hiervoor in je home-directory een nieuwe directory:

mkdir php-pdo && cd php-pdo

maak hierin een directory voor de website:

mkdir web-pdo && cd web-pdo

Maak hierin een index.php:

nano index.php

Plaats daarin je php met daarin de PDO verbinding:

<?php

$user = "root";
$password = "password";
$database = "db_noorderpoort";
$table = "Teachers";
try {
  $db = new PDO("mysql:host=172.17.0.2;dbname=$database", $user, $password);
  echo "<h2>Print Teachers Noorderpoort</h2><ol>";
  foreach($db->query("SELECT FirstName FROM $table") as $row) {
    echo "<li>" . $row['FirstName'] . "</li>";
  }
  echo "</ol>";
} catch (PDOException $e) {
    print "Error!: " . $e->getMessage() . "<br/>";
    die();
}
?>

Zorg ervoor dat de namen/IP-adres/Wachtwoorden/databases/tabellen overeenkomen met jouw omgeving!

Het (interne-docker)ip-adres van je MariaDB haal je op met:

docker inspect mariadbdemo | grep IPAddress

Als dit gereed staat ga je 1 directory terug naar:

cd ~/php-pdo

Hier maak je de Dockerfile met de volgende inhoud:

FROM php:8.0-apache
COPY ./web-pdo/ /var/www/html/
RUN docker-php-ext-install pdo pdo_mysql

Zie dat er een php installatie plaats vindt om pdo verbindingen mogelijk te maken.

Maak nu van je Dockerfile een image:

docker build -t my-php-pdo .

En run daarna de image op een andere poort dan poort 80:

docker run --name my-php-pdo -p 8080:80 -d my-php-pdo

met docker ps controleren of de container draait:

CONTAINER ID   IMAGE        COMMAND                  CREATED          STATUS          PORTS                  NAMES
85dff9d35bfe   my-php-pdo   "docker-php-entrypoi…"   23 minutes ago   Up 23 minutes   0.0.0.0:8080->80/tcp   my-php-pdo
d77d71d759e1   my-php       "docker-php-entrypoi…"   46 minutes ago   Up 46 minutes   0.0.0.0:80->80/tcp     my-php-app
2e11bc5dcba4   mariadb      "docker-entrypoint.s…"   5 hours ago      Up 43 minutes   3306/tcp               mariadbdemo

Daarna ga je naar de website met een browser om te zien of je database nu beschikbaar is op de website.

Docker opdrachten

Met de onderstaande opdrachten kunnen we de container starten, stoppen, verwijderen, enz.

Lijst van alle draaiende containers

docker ps

lijst van alle containers, ook de gestopte

docker ps -a

Lijst van alle images

docker images

Stoppen van je Apache container

docker stop my-php-app

Starten van je Apache container

docker start my-php-app

Updaten van je draaiende container (dit geval automatisch starten na reboot van je server)

docker update --restart=unless-stopped my-php-app

Verwijderen van je container

docker rm my-php-app

Verwijderen van je image

docker rmi my-php-image

Docker systeem opschonen, alle niet gebruikte containers en images worden hiermee verwijderd

docker system prune

Bash shell in je container krijgen

docker exec -it my-php-app /bin/bash

Opdracht

De opdracht voor PHP container staat op ItsLearning. Lees de opdracht goed en lever hem daarna weer in als je gereed bent.

Les 6: OpenVPN container

In deze les gaan we een OpenVPN server opzetten in Docker. VPN verbindingen zijn de afgelopen jaren steeds belangrijker geworden, denk aan het werken op een onveilig netwerk, werken vanaf huis, remote beheer, enz. 
OpenVPN maakt het mogelijk dat we beveiligd verbinding kunnen maken met een server, er een tunnel naar het eindpunt gecreërd wordt en van cliënt tot server een encryptie op de verbinding zit.

 

Daarnaast zullen we onze VPN data opslaan in een aparte volume, dit is nieuw en hebben ze niet eerder gedaan. Volg hiervoor de stappen op de volgende pagina's.

Docker opdrachten

Met de onderstaande opdrachten kunnen we de container starten, stoppen, verwijderen, enz.

Lijst van alle draaiende containers

docker ps

lijst van alle containers, ook de gestopte

docker ps -a

Lijst van alle images

docker images

Stoppen van je Apache container

docker stop openvpn

Starten van je Apache container

docker start openvpn

Updaten van je draaiende container (dit geval automatisch starten na reboot van je server)

docker update --restart=unless-stopped openvpn

Verwijderen van je container

docker rm openvpn

Verwijderen van je image

docker rmi openvpn

Docker systeem opschonen, alle niet gebruikte containers en images worden hiermee verwijderd

docker system prune

Bash shell in je container krijgen

docker exec -it openvpn /bin/bash

Volume aanmaken

Maak een volumecontainer. In deze tutorial wordt de $OVPN_DATAomgevingsvariabele gebruikt. Stel dit in op wat je maar wilt. De standaardwaarde ovpn-datawordt aanbevolen voor enkele OpenVPN Docker-containerservers. Het instellen van de variabele in de shell maakt gebruik van stringvervanging om te voorkomen dat de gebruiker deze handmatig vervangt in een stap in de tutorial:

OVPN_DATA="ovpn-data-noorderpoort"

Maak de volume met:

docker volume create --name $OVPN_DATA

Initialiseer de $OVPN_DATAcontainer die de configuratiebestanden en certificaten zal bevatten en vervang deze vpn.example.comdoor je FQDN. De vpn.example.comwaarde moet de volledig gekwalificeerde domeinnaam zijn die je gebruikt om met de server te communiceren. Dit veronderstelt dat de DNS-instellingen al zijn geconfigureerd. Als alternatief is het mogelijk om alleen het IP-adres van de server te gebruiken, maar dit wordt niet aanbevolen.

docker run -v $OVPN_DATA:/etc/openvpn --rm kylemanna/openvpn ovpn_genconfig -u udp://VPN.EXAMPLE.COM

docker run -v $OVPN_DATA:/etc/openvpn --rm kylemanna/openvpn ovpn_genconfig -u udp://192.168.182.128

Genereer de EasyRSA PKI-certificeringsinstantie. Je wordt gevraagd om een ​​wachtwoordzin voor de CA-privésleutel. Kies een goede en onthoud het; zonder de wachtwoordzin is het onmogelijk om clientcertificaten uit te geven en te ondertekenen:

docker run -v $OVPN_DATA:/etc/openvpn --rm -it kylemanna/openvpn ovpn_initpki

Let op, de beveiliging van de $OVPN_DATAcontainer is belangrijk. Het bevat alle privésleutels om de server na te bootsen en alle clientcertificaten. Houd hier rekening mee en controleer de toegang waar nodig. De standaard OpenVPN-scripts gebruiken een wachtwoordzin voor de CA-sleutel om de beveiliging te verhogen en het uitgeven van valse certificaten te voorkomen.

docker volume ls && docker volume create
docker volume ls && docker volume create

Starten OpenVPN-container

Om de container te starten gebruik je:

docker run -v $OVPN_DATA:/etc/openvpn -d -p 1194:1194/udp --cap-add=NET_ADMIN kylemanna/openvpn

Het enige wat je nu nog moet doen is het genereren van cliënt configuratie bestanden, die je naar gebruikers kan sturen zodat ze verbinding kunnen maken met je VPN-server.

Genereren van een cliënt zonder wachtwoord:

docker run -v $OVPN_DATA:/etc/openvpn --rm -it kylemanna/openvpn easyrsa build-client-full CLIENTNAME nopass

Daarna moet je de cliënt-config bestand ophalen:

docker run -v $OVPN_DATA:/etc/openvpn --rm kylemanna/openvpn ovpn_getclient CLIENTNAME > CLIENTNAME.ovpn

Vervang CLIENTNAME voor een gebruikersnaam of IP-adres van de server, bedenk hier goed wat voor jouw handig is en hoe je de configuraties uit elkaar houdt.

 

Het enige wat je nu nog moet doen is het ophalen van je VPN-configuratie, maar die staat op je server. Een manier om dit bestand op te halen is met SCP (secure copy), dat via ssh bestanden kan sturen en ophalen van je server.

De syntaxis voor scpis:

Als je op de computer bevindt waarvan je een bestand naar een externe computer wilt verzenden:

scp /file/to/send username@remote:/where/to/put

Hier remotekan het een FQDN of een IP-adres zijn.

Aan de andere kant, als je op de computer een bestand van een externe computer wilt ontvangen:

scp username@remote:/file/to/send /where/to/put

Wij willen een bestand ophalen van de server:

scp student@192.168.182.128:/home/student/patrick.ovpn /home/patrick/
maken van een VPN-config voor een cliënt
maken van een VPN-config voor een cliënt
Cliënt bestand ophalen met SCP
Cliënt bestand ophalen met SCP

Verbinding maken met je VPN-server

Voor het testen van je VPN-verbinding is het noodzakelijk dat OpenVPN correct is geïnstalleerd op de cliënt-computer.

Om de VPN-config/VPN-verbinding te starten gebruiken we:

openvpn --config CLIENTNAME.ovpn

Controleer je verbinding met bijvoorbeeld ping, nslookup, traceroute, enz.

Denk om je Firewall op de server
Denk om je Firewall op de server
VPN verbinden
VPN verbinden

BELANGRIJK!

Laat de shell met de VPN-verbinding altijd open staan, met {CTRL}+C stop je de VPN-verbinding.

tun0 toegevoegd aan je network-interfaces
tun0 toegevoegd aan je network-interfaces
traceroute om te zien dat het de hops over de server gaan
traceroute om te zien dat het de hops over de server gaan

Opdracht

De opdracht voor deze les staat op ItsLearning, kijk goed naar de gebruikers namen voor je VPN-configuraties.

Les 7: SVN container

Les 8: Docker networking

Docker macvlan bridge

MACVLAN creëert meerdere virtuele netwerkinterfaces met verschillende MAC-adressen. Op deze manier, als je systeem meerdere IP-adressen met MAC-adressen heeft, kunnen we meerdere virtuele netwerkinterfaces maken die elk hun eigen IP-adres en MAC-adres hebben.

MACVLAN hoeft geen mac-adressen van de systemen binnen het netwerk te leren (identificeren) om verkeer te verdelen, aangezien het elk Mac-adres kent, dit maakt het snel en gemakkelijk in te stellen dan een bridge-type netwerk.

Problemen met poortbinding van docker-containers:

  • Als een container poort 8000 van de host gebruikt, kunnen geen andere containers die poort gebruiken.

  • Het koppelen van meerdere poorten aan de container kan worden gedaan door het poortbereik op te geven, maar deze bewerking kost meer tijd, afhankelijk van nr. van te binden poorten.

  • IPTables-regels worden omslachtig omdat de bindingen toenemen.

Voordelen van MACVLAN:

  • IPTables worden niet beïnvloed.

  • Geen poortbinding.

  • Makkelijk op te zetten.

  • Sneller dan bridge-netwerken.

MACVLAN-netwerk maken:

Voorbeeld:

Host-IP: 192.168.182.130

Hostsubnet: 192.168.182.0

Gastheermasker: 24

Hostgateway: 192.168.182.2

Host ethernet-interface: ens33

docker network create -d macvlan -o macvlan_mode=bridge --subnet=192.168.182.0/24 --gateway=192.168.182.2 -o parent=ens33 macvlan_bridge

Bovenstaande opdracht maakt netwerk met de naam 'macvlan_bridge'. Controleer goed jouw gegevens dat die overeenkomen en pas de opdracht op jouw omgeving aan.

Een container draaien met het 'macvlan_bridge'-netwerk:

Voorbeeld:

Host bevat meerdere openbaar toegankelijke IP-adressen met MAC-adressen.

Extra IP/MAC host: 192.168.182.10/00:50:56:00:60:42

docker run --name cont1 --net=macvlan_bridge --ip=192.168.182.10 --mac-address 00:50:56:00:60:42 -itd nginx

Voorbeeld zonder MAC-adres:

docker run --name cont2 --net=macvlan_bridge --ip=192.168.182.11 -itd nginx

Voorbeeld van een andere container:

docker run --name cont3 --net=macvlan_bridge --ip=192.168.182.12 -itd httpd

Controleer of de containers draaien met:

docker ps

Controleer op IP-adres in je URL:

Om de container en de netwerk instellingen te controleren gaan we met docker inspect de container instellingen bekijken.

docker container inspect cont2
"Networks": {

                "macvlan_bridge": {

                    "IPAMConfig": {

                        "IPv4Address": "192.168.182.11"

                    },

                    "Links": null,

                    "Aliases": [

                        "f68a60aba763"

                    ],

                    "NetworkID": "d6adfdaa0159d03df6a5106c7d5b397283af35a41424f9daf7fa25cf3140d5c3",

                    "EndpointID": "286a9f6bf98384e426e703c4124e2135537c6a4bc1bde5dc7879e7b1338b505b",

                    "Gateway": "192.168.182.2",

                    "IPAddress": "192.168.182.11",

                    "IPPrefixLen": 24,

                    "IPv6Gateway": "",

                    "GlobalIPv6Address": "",

                    "GlobalIPv6PrefixLen": 0,

                    "MacAddress": "02:42:c0:a8:b6:0b",

                    "DriverOpts": null

Les 11: Kubernetes

Kubernetes is een open-source framework voor containerorkestratie dat is gebaseerd op de omgeving van Google. Het stelt je in staat applicaties uit te voeren met containers in een productie-ready cluster. Kubernetes heeft veel bewegende onderdelen en er zijn talloze manieren om de onderdelen ervan te configureren - van de verschillende systeemcomponenten, netwerktransportstuurprogramma's, CLI-hulpprogramma's en niet te vergeten applicaties en workloads.

Les 12: Kubernetes servers

In deze les installeren we Kubernetes 1.16 op een virtuele machine met Ubuntu 20.04. Aan het einde kun je beginnen te leren hoe je met Kubernetes kunt communiceren via de CLI kubectl.

 

Kubernetes installatie

Benodigdheden

Ik raad aan om de Ubuntu 20.04 omgeving te gebruiken uit voorgaande lessen voor het doorlopen van deze les, hiermee kan je de lessen lokaal uitvoeren. Je hebt 1 master VM nodig en 2 worker VM's. Je kunt er ook voor kiezen om dit in de cloud uit te voeren en 3 virtuele machines te bestellen.

Aanbevolen

Zorg voor hostnamen die overeenkomen met de functie van de server. Bijvoorbeeld k8s-master, k8s-worker1, enz.

Achteraf of bij importeren kun je de hostname veranderen met de volgende opdracht

sudo hostnamectl set-hostname new-computer-name-here

Reboot na het aanpassen van de hostname.

Installatie

(Installatie gebeurt voor de volgende onderdelen op alle 3 servers)

De hosts hebben een paar minuten nodig om op te starten, waarna je bij elk moet inloggen via sshen begin met het installeren van dezelfde set pakketten voor Docker en Kubernetes. containerdis nu beschikbaar als alternatieve runtime, maar is iets meer werk om te configureren.

  • Installeer Docker

Een bekende/geteste versie van Docker moet worden gebruikt met de kubeadmbootstrapper, anders zullen we mogelijk onbekend gedrag tegenkomen. De apt-pakketrepository bevat een voldoende oude versie voor ons.

$ sudo apt-get update \
  && sudo apt-get install -qy docker.io
  • Voeg de Kubernetes-pakketbron toe

Deze opdracht uit de Kubernetes-documentatie voegt de pakketrepository toe waar kubeadm, kubectlen de gerelateerde pakketten worden regelmatig gepubliceerd.

$ sudo apt update \
  && sudo apt-get install -y apt-transport-https \
  && curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
  • Voer een pakketupdate uit:
$ echo "deb http://apt.kubernetes.io/ kubernetes-xenial main" \
  | sudo tee -a /etc/apt/sources.list.d/kubernetes.list \
  && sudo apt-get update

Werk nu uw pakketlijst bij met apt update.

  • Installeren kubelet, kubeadmenkubernetes-cni

Het kubeletis verantwoordelijk voor het plannen, beheren en draaien van containers op je hosts. kubeadmtool is een gebruiksgemak dat gereed is voor productie en dat wordt gebruikt om de verschillende componenten van een werkcluster te configureren. Het kubernetes-cnipakket vertegenwoordigt de netwerkcomponenten die niet rechtstreeks in Kubernetes zijn ingebouwd.

CNI staat voor Container Networking Interface, een specificatie die definieert hoe netwerkstuurprogramma's moeten communiceren met Kubernetes. CNI-netwerkstuurprocessen worden uitgevoerd met UNIX-pipes en worden voor elk verzoek forked​.

sudo apt-get update \
  && sudo apt-get install -yq \
  kubelet \
  kubeadm \
  kubernetes-cni

We moeten de Kubernetes-pakketten in de wacht zetten, want als we dat niet doen, wanneer er een nieuwere versie wordt uitgebracht en we draaien apt upgrade, kunnen we eindigen met een onverwachte hobbel in onze Kubernetes-versie.

sudo apt-mark hold kubelet kubeadm kubectl
  • Swap moet zijn uitgeschakeld

De beheerders van Kubernetes besloten dat het gebruik van wisselgeheugen kan leiden tot onvoorspelbaar gedrag en gaven er de voorkeur aan om het uit te schakelen dan om te kampen met een van de bijwerkingen die kunnen optreden.

Je kunt controleren of je swap heeft ingeschakeld door in te typen cat /proc/swaps. Als je een wisselbestand of partitie hebt ingeschakeld, schakel deze dan uit met swapoff. U kunt dit permanent maken door het wisselbestand in /etc/fstab.

cat /proc/swaps
Filename                                Type            Size    Used    Priority
/dev/md127                              partition       1995772 0       -2
$ sudo swapoff /dev/md127

$ sudo vim /etc/fstab

UUID=2358eec8-dda6-4212-9cf6-92f515a1b631       /       ext4    errors=remount-ro       0       1
#UUID=b038c1b7-fa7f-4f20-b554-6c2885d73ba5      none    swap    none    0       0

Belangrijk!

Op dit punt zou je de bovenstaande stappen op elk van je servers moeten hebben uitgevoerd. Dit zijn allemaal veel voorkomende stappen dat op alle nodes uitgevoerd moet worden.

 

 

 

Kubeadm

kubeadm streeft ernaar om een ​​veilig cluster uit de doos te creëren via mechanismen zoals RBAC.

Terwijl containerorkestrators zoals Docker Swarm monolithisch waren en gedistribueerd als een enkel binair bestand, hanteert Kubernetes een modulaire en uitbreidbare aanpak. Netwerken wordt pas toegevoegd nadat het eerste cluster is gemaakt en het is aan de gebruiker om te kiezen uit een van de tientallen beschikbare netwerkstuurprogramma's.

We gebruiken vandaag Weave net van Weaveworks. Weave net is eenvoudig te installeren en presteert erg goed in benchmarking met vergelijkbare stuurprogramma's en kan functies bieden zoals wachtwoordbeveiliging en link-encryptie.

  • Bepaal welk IP-adres je voor Kubernetes wilt gebruiken

    Kubernetes stelt zijn API-server bloot via het privé- of openbare netwerk. Als je het openbare netwerk gebruikt, kun je het cluster vanaf je eigen laptop of je CI/CD-server beheren, maar er kunnen hogere kosten in rekening worden gebracht voor gegevens die via het openbare internet worden doorgegeven.

    Als je het cluster alleen binnen je interne privénetwerk wilt gebruiken, gebruik dan het private IP. Voor deze tutorial gebruiken we het interne netwerk dat VMWare ons gegeven heeft.

  • Zoek het IP-adres van het prive-netwerk

Kubeadm installeren op de master-node

Initialiseer je cluster met kubeadm

Je hoeft deze stap alleen uit te voeren op je aangewezen hoofdserver, voor mij was dat k8s-master-node.

We gebruiken nu het interne IP-adres om de Kubernetes-API uit te zenden, in plaats van het internetgerichte adres (lokaal hebben we dit niet, in de cloud wel).

Je moet --apiserver-advertise-address vervangen door het IP-adres van je master node-host.

$ sudo kubeadm init --apiserver-advertise-address=10.80.0.133 --kubernetes-version stable

  • --apiserver-advertise-address bepaalt welk IP-adres Kubernetes zijn API-server moet adverteren.

  • --skip-preflight-checksstaat kubeadmtoe om de host-kernel te controleren op vereiste functies. Als je problemen tegenkomt waarbij een host de kernel-metagegevens heeft verwijderd, moet je mogelijk met deze vlag draaien.

  • --kubernetes-version stable-1.16dit pint de versie van het cluster naar 1.16, maar als je bijvoorbeeld Kubernetes 1.15 wilt gebruiken, verander dan gewoon de versie. Als je deze vlag verwijdert, wordt alles gebruikt dat geldt als "nieuwste".

Wij gebruiken de stable variant van Kubernetes, omdat deze werkt met Ubuntu 20.04

Je krijgt deze output als alles volgens plan is verlopen, zo niet, controleer dan de bovenstaande stappen.

 

Alleen uitvoeren als je geen sudo gebruiker hebt!

  • Configureer een onbevoegd gebruikersaccount (als je deze niet hebt)

De Ubuntu-installatie wordt geleverd zonder een onbevoegd gebruikersaccount, dus laten we er een toevoegen.

$ sudo useradd k8s -G sudo -m -s /bin/bash
$ sudo passwd k8s
  • Configureer omgevingsvariabelen voor de nieuwe gebruiker

Je kunt nu je omgeving configureren met de instructies aan het einde van het init-bericht hierboven.

Ga hier verder!

Schakel over naar het nieuwe gebruikersaccount en configureer het KUBECONFIG

sudo su k8s

cd $HOME
sudo cp /etc/kubernetes/admin.conf $HOME/
sudo chown $(id -u):$(id -g) $HOME/admin.conf

Probeer nu het KUBECONFIG-bestand uit:

echo "export KUBECONFIG=$HOME/admin.conf" | tee -a ~/.bashrc
source ~/.bashrc

Probeer een kubectlcommando om te zien of het masterserver nu in de lijst staat, merk op dat het voorlopig een NotReadystatus heeft

$ kubectl get node
NAME               STATUS     ROLES    AGE     VERSION
k8s-master         NotReady   master   3m32s   v1.20.2
  • Pas uw pod-netwerk aan

We zullen nu de configuratie toepassen op het cluster met kubectlen ons nieuwe KUBECONFIGbestand. Dit maakt netwerken mogelijk en ons hoofdserver wordt Ready, op dat moment gaan we naar de andere werkservers.

sudo mkdir -p /var/lib/weave
head -c 16 /dev/urandom | shasum -a 256 | cut -d" " -f1 | sudo tee /var/lib/weave/weave-passwd

kubectl create secret -n kube-system generic weave-passwd --from-file=/var/lib/weave/weave-passwd

Omdat we het standaard Pod-netwerk gebruiken voor hostnetwerken, moeten we een ander privé-subnet voor Weave-net gebruiken om conflicten te voorkomen. Gelukkig is 192.168.0.0/24 ruimte beschikbaar voor gebruik.

$ kubectl apply -f "https://cloud.weave.works/k8s/net?k8s-version=$(kubectl version | base64 | tr -d '\n')&password-secret=weave-passwd&env.IPALLOC_RANGE=192.168.0.0/24"

We hebben nu het netwerk geconfigureerd voor de pods.

  • Optionele stap - taint the master

Kubernetes streeft ernaar een zeer beschikbare clustering container orchestrator te zijn waarbij workloads met redundantie over meerdere hosts worden verdeeld. We kunnen echter een enkele master node dwingen om workloads uit te voeren voor ontwikkeling door de "taint" te verwijderen:

Dit wordt alleen aanbevolen als je met een enkele host werkt, voer deze stap niet uit als je andere hosts aan het cluster toevoegt.

$ kubectl taint nodes --all node-role.kubernetes.io/master-

Toevoegen van worker-nodes

Toen we kubeadm initop het master-server uitvoerden, stuurde het een token uit dat 24 uur geldig is. We moeten dat nu gebruiken om ons bij andere hosts te voegen.

kubeadm join 192.168.182.130:6443 --token q677gq.cb3c90i1k5y0d852 \
    --discovery-token-ca-cert-hash sha256:bef0ec14c4f766853c2b9354500c5f66787f14d08d8dc255fa4c786c07b340a1

Als je op dit punt een foutmelding krijgt, komt dit waarschijnlijk doordat je een stap hierboven bent vergeten. Onthoud dat je het wisselgeheugen voor elke host moet uitschakelen, niet alleen voor de master.

Denk om UFW...... zelf gemaakte fout ;-)

Voer de join-stap uit op elke host.

Ga terug naar de sshsessie voor de hoofdserver waar je bent aangemeld als de k8s of student onbevoegde gebruiker.

Je zou nu al uw knooppunten in de Readystatus moeten zien.

Testen van je k8s-cluster

  • Controleer of het werkt

Veel van de Kubernetes-componenten worden als containers op je cluster uitgevoerd in een verborgen naamruimte met de naam kube-system. Je kunt zien of ze werken en info opvragen:

kubectl cluster-info

kubectl cluster-info dump > cluster_info.txt

 

 

Zoals u kunt zien, bevinden alle services zich in een staat Runningdie duidt op een gezond cluster. Als deze componenten nog steeds van internet worden gedownload, kan het lijken alsof ze niet zijn gestart.

Je kunt ook kubectl get all --all-namespaces. Een snelkoppeling voor --all-namespacesis -A.

Uitvoeren van een container

Je kunt nu een container op je cluster uitvoeren. Kubernetes organiseert containers in Pods die een gemeenschappelijke IP-adres te delen, zijn altijd gepland op hetzelfde server (host) en kan opslagvolumes delen.

Controleer eerst of er geen pods (containers) draaien met:

$ kubectl get pods

Laten we beginnen met het controleren van de status van het cluster. Al je nodes zouden in de status GEREED moeten zijn.

 

We maken een implementatie van NGINX met behulp van de NGINX- image.

Je kunt nu de status van je implementatie zien.

Als je meer details over je implementatie wilt zien, kun je de opdracht describe uitvoeren. Het is bijvoorbeeld mogelijk om te bepalen hoeveel replica's van de implementatie worden uitgevoerd. In ons geval verwachten we een replica van 1 actief te zien (dwz 1/1 replica's).

Nu je Nginx-implementatie actief is, wil je misschien de NGINX- service beschikbaar stellen aan een openbaar IP-adres dat bereikbaar is op het internet.

Kubernetes biedt verschillende opties bij het presenteren van je service op basis van een functie genaamd Kubernetes Service-types en ze zijn:

  1. ClusterIP - Dit servicetype stelt de service over het algemeen bloot op een intern IP-adres, dat alleen bereikbaar is binnen het cluster en mogelijk alleen binnen de clusternodes.
  2. NodePort - Dit is de eenvoudigste optie om je service toegankelijk te maken buiten je cluster, op een specifieke poort (de NodePort genoemd ) op elk node in het cluster. We zullen deze optie zo illustreren.
  3. LoadBalancer - Deze optie maakt gebruik van externe load-balancing-services die door verschillende providers worden aangeboden om toegang tot je service mogelijk te maken. Dit is een betrouwbaardere optie wanneer je nadenkt over hoge beschikbaarheid voor je service, en heeft meer functies dan standaardtoegang.
  4. ExternalName - Deze service leidt verkeer om naar services buiten het cluster. Als zodanig wordt de service dus toegewezen aan een DNS-naam die buiten je cluster kan worden gehost. Het is belangrijk op te merken dat dit geen proxy gebruikt.

Het standaard servicetype is ClusterIP .

In ons scenario willen we het NodePort Service-type gebruiken omdat we zowel een openbaar als privé IP-adres hebben en we voorlopig geen externe load balancer nodig hebben. Met dit servicetype wijst Kubernetes deze service toe aan poorten in het bereik van 30000+ .

 

Voer de opdracht get svc uit om een ​​samenvatting van de service en de blootgestelde poorten te zien.

 

Nu kunt je controleren of de Nginx- pagina op alle knooppunten bereikbaar is met het curl-commando.

# curl master-node-IP:32021
# curl node-1-IP:32021 
# curl node-2-IP:32021

Kubernetes-dashboard

Het Kubernetes-dashboard biedt een visuele weergave van de bronnen in het cluster en is ook toegankelijk vanaf uw lokale computer.

Hiervoor zullen we de dashboard moeten ophalen met de volgende opdracht

kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/v2.0.0/aio/deploy/recommended.yaml

 

Nu zullen we controleren of de bronnen met succes zijn gemaakt en of de pods worden uitgevoerd in de nieuwe naamruimte van het dashboard:

kubectl get pods -n kubernetes-dashboard

Nu moeten we een serviceaccount maken dat we zullen gebruiken om toegang te krijgen tot het dashboard: ons account wordt een beheerdersaccount, zodat het via het dashboard nieuwe bronnen kan bekijken, wijzigen en aanmaken. Dit kunnen we doen door de rollen toe te voegen via een clusterRole.

Om het serviceaccount te maken, maak je een nieuw bestand aan:

nano dashboard-admin.yaml

plak vervolgens de volgende inhoud erin:

apiVersion: v1
kind: ServiceAccount
metadata:
  name: admin-user
  namespace: kubernetes-dashboard

---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: admin-user
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
- kind: ServiceAccount
  name: admin-user
  namespace: kubernetes-dashboard

Nadat we het bestand hebben opgeslagen, passen we het toe via deze opdracht:

kubectl apply -f dashboard-admin.yaml

Om verbinding te kunnen maken met het dashboard, moeten we het token vinden dat door het serviceaccount is gegenereerd.

Om het token te krijgen, gebruik je eenvoudig de volgende opdracht: deze opdracht extraheert het geheime object dat aan het account is gekoppeld als JSON-indeling, het neemt het token en decodeert het met base64 om het gewenste token te krijgen:

kubectl get secret -n kubernetes-dashboard $(kubectl get serviceaccount admin-user -n kubernetes-dashboard -o jsonpath="{.secrets[0].name}") -o jsonpath="{.data.token}" | base64 --decode

Bewaar dit token, want we hebben het later nodig.

Toegang tot het dashboard

Een ding dat je moet weten over het Kubernetes-dashboard is dat het alleen toegankelijk is via het localhost-adres op de computer waarop het draait. Daarom hebben we een SSH-tunnel naar de server nodig.

Om dit te doen, kun je met deze opdracht een SSH-tunnel maken. Vervang gewoon de <user> en <master_public_IP> door je Kubernetes master IP en de gebruiker die je gebruikt om er toegang toe te krijgen.

ssh -L localhost:8001:127.0.0.1:8001 <gebruiker>@<master_public_IP>

In mijn geval heb ik deze opdracht gebruikt om mijn SSH-tunnel te maken:

Gebruik deze opdracht om het Dashboard te starten:

kubectl proxy

Nu kun je deze URL gebruiken om toegang te krijgen tot je Dashboard-webinterface:

http://localhost:8001/api/v1/namespaces/kubernetes-dashboard/services/https:kubernetes-dashboard:/proxy/

De volgende pagina zal verschijnen, je kunt het token gebruiken dat we in de vorige stap hebben opgeslagen om in te loggen:

 

Het Kubernetes-dashboard gebruiken

Via het dashboard kunt u de verschillende soorten Kubernetes-bronnen bekijken:

Het dashboard maakt het eigenlijk gemakkelijker om bronnen te maken: dus in plaats van complexe YAML-bestanden te schrijven, kun je de apps implementeren door simpelweg een formulier in te vullen.

We nemen als voorbeeld de implementatie van een basiswebapplicatie:

In het eerste gedeelte hebben we de naam van de app gespecificeerd, de docker-image die we zullen gebruiken. We noemden ook het aantal te maken pods. En toen hebben we een externe service toegevoegd, de poort en het protocol.

Troubleshooten:

 

Ik zocht naar de docker-image: apache, echter deze heeft een andere naam. De containers kun je vinden op Docker-hub, zie afbeelding hieronder.

Nadat aangepast te hebben in een nieuwe deployment, werkte het naar behoren en zouden we ervoor kunnen kiezen een aangepaste installatie te doen. Je kunt meerdere variabelen meegeven tijdens het deployen van je images. De oude/foute nog even verwijderen.

Zie wat er allemaal veranderd is en controleer waar de Pods draaien.

Om te controleren of apache werkt, zoeken we de poort op onder "Discovery and Load Balancing".

Zo zien we dat Kubernetes zowel op de CLI and in de Dashboad-Kubernetes Pods kan deployen en dat het super werkt.

Echter dit is pas het begin van onze mooie Kubernetes reis ;-).

YAML implementeren met behulp van het Kubernetes-dashboard

Nu zullen we de Nginx app implementeren met behulp van een YAML-bestand via het Kubernetes-dashboard.

Gebruik de volgende YAML-bronnen bij het maken van een nieuwe app met YAML:

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-yaml
spec:
  strategy:
    type: Recreate
  selector:
    matchLabels:
      app: nginx-yaml
  replicas: 3
  template:
    metadata:
      labels:
        app: nginx-yaml
    spec:
      containers:
      - name: nginx
        image: nginx
        ports:
        - containerPort: 80

---
apiVersion: v1
kind: Service
metadata:
  name: nginx-svc-yaml
  labels:
    app: nginx
  annotations:
    description: My web App deployment
spec:
  externalTrafficPolicy: Cluster
  ports:
  - name: http
    port: 80
    protocol: TCP
    targetPort: 80
  selector:
    app: nginx-yaml
  type: LoadBalancer

 

Implementeer de app en controleer de implementaties om te controleren of deze met succes is gemaakt:

Top het werkt!

Kijk welke app's je nog meer op deze manier kunt maken.......

Opdracht Kubernetes installatie

De opdracht voor deze les staat op ItsLearning. Je zult aan de hand van de stappen genoemd in deze les zelf een Kubernetes cluster maken en je eerste Pods deployes.

Les 13: Kubernetes recap

Deze les gaan we rustig alles nog een keer bij langs om te wennen aan de omvang van Kubernetes en vertrouwd te raken met de opdrachten die we kunnen uitvoeren.

Kubectl

In deze sectie zullen we het kernconcept van kubernetes leren, zoals Pod, cluster, implementatie, replicaset. Het idee is om het simpel te houden en intuïtiever te leren.

In het begin hebben we één master node en een worker node opgezet

  1. kube-master
  2. kube-worker

kubectl - Hoofd-CLI-tool voor het uitvoeren van opdrachten en het beheren van Kubernetes-clusters. dus wat is het cluster?

kubectl cluster-info

 

cluster bestaat uit ten minste één clustermaster en meerdere werkmachines die nodes worden genoemd

Controleer de nodes die zich bij het cluster hebben aangesloten

kubectl get nodes

Kubernetes API Resources

  1. Pod: Kubernetes-pod is een groep containers die samen op dezelfde host worden geïmplementeerd
  2. Service: een service in Kubernetes is een REST-object, vergelijkbaar met een pod
  3. Deploy: een implementatiecontroller biedt declaratieve updates voor pods en replicasets
  4. Replica Set: Een ReplicaSet zorgt ervoor dat een bepaald aantal pod-replica's op een bepaald moment wordt uitgevoerd

Voorbeeld: maak een lijst van alle bronnen in de naamruimte

kubectl get all

Om alle ondersteunde resourcetypen weer te geven, samen met hun korte namen, API-groep, of ze een naamruimte hebben en Kind:

kubectl api-resources

Afkortingen:

  • po: Pod
  • svc: Service
  • deploy: Deployment
  • rs: Replicaset

Lichte Kubernetes flow

We gaan een simpele flow maken om te zien wat er gebeurt en later aanpassen. Start hiervoor een enkele nginx met één replicaset.

kubectl run nginx --image=nginx --replicas=1

We kunnen veel meer informatie over elk van deze pods ophalen met behulp van:

kubectl describe pod nginx

Er zal een grote YAML-uitvoer zijn, zoals hieronder.

Hier zie je de configuratiegegevens over de container(s) en pod (labels, resourcevereisten, enz.), Evenals statusinformatie over de container(s) en pod (status, gereedheid, aantal herstarten, gebeurtenissen, enz.) .

De containerstatus is Wachten, Bezig of Beëindigd. hier kun je zien dat voor een container in de status Running, het systeem je vertelt wanneer de container is gestart.

Ready geeft aan of de container de laatste gereedheidstest heeft doorstaan.

Om een ​​lijst te maken van alle evenementen die u kunt gebruiken:

kubectl get events

Haal de implementatieconfiguratie van nginx op met de opdracht:

kubectl get deployment nginx

Tijdens de initialisatiestatus hebben we de kubernetes verteld om slechts één replica te onderhouden door de vlag in te stellen --replicas=1.

Verwijder de nginx-pod, om de pod te verwijderen specificeer de podnaam.

kubectl delete pod nginx

Alleen uitvoeren als je hem ook echt wilt verwijderen, maar we hebben net geleerd hoe je snel weer een pod kunt deployen.

 

Opschalen van Pods

Om de pods op te schalen, vertel kubectl hoeveel huidige replica's er zijn (huidige replica's) en hoeveel er moeten worden geschaald (replica's).

kubectl scale --current-replicas=1 --replicas=3 deployment/nginx

Op de achtergrond worden twee nieuwe containers gemaakt en ingezet.

 

Kijk naar de evenementen

kubectl get events

Verlaag het aantal pods

kubectl scale --current-replicas=3 --replicas=1 deployment/nginx

Nieuwe node aan het cluster toevoegen

Voor het toevoegen van een nieuwe node aan het kubernetes- cluster zijn token en discovery-token-ca-cert-hash vereist.

Maak eerst een token met de kubeadm- opdracht in de kube-master setup:

kubeadm token create

discovery-token-ca-cert-hash:

openssl x509 -pubkey -in /etc/kubernetes/pki/ca.crt | openssl rsa -pubin -outform der 2>/dev/null | openssl dgst -sha256 -hex | sed 's/^.* //'

De output discovery-token-ca-cert-hash-waarde.

Zodra het token is gemaakt, voeg je zich bij de nieuwe node k8s-worker3 met behulp van de token en tokencacert- waarde. Voer onderstaande opdracht uit op de nieuwe node.

kubeadm join 192.168.182.130:6443 --token {jouw token} --discovery-token-ca-cert-hash sha256:{jouw hash waarde}

Schaal nu nog eens de nginx-applicatie en zie op welke node het draait.

  • Het arrangement Linux gevorderd is gemaakt met Wikiwijs van Kennisnet. Wikiwijs is hét onderwijsplatform waar je leermiddelen zoekt, maakt en deelt.

    Auteurs
    Patrick Hulshof
    Laatst gewijzigd
    2021-05-30 10:16:38
    Licentie

    Dit lesmateriaal is gepubliceerd onder de Creative Commons Naamsvermelding 4.0 Internationale licentie. Dit houdt in dat je onder de voorwaarde van naamsvermelding vrij bent om:

    • het werk te delen - te kopiëren, te verspreiden en door te geven via elk medium of bestandsformaat
    • het werk te bewerken - te remixen, te veranderen en afgeleide werken te maken
    • voor alle doeleinden, inclusief commerciële doeleinden.

    Meer informatie over de CC Naamsvermelding 4.0 Internationale licentie.

    Aanvullende informatie over dit lesmateriaal

    Van dit lesmateriaal is de volgende aanvullende informatie beschikbaar:

    Toelichting
    Deze lessen zijn voor module 4 & 5 voor Linux. Deze lessen gaan in op Docker, Kubernetes, netwerkbeheer met Linux.
    Eindgebruiker
    leerling/student
    Moeilijkheidsgraad
    gemiddeld
    Studiebelasting
    4 uur 0 minuten

    Bronnen

    Bron Type
    Officiële Apache image
    https://hub.docker.com/_/httpd     		Link
    Docker run opties
    https://docs.docker.com/engine/reference/commandline/run/     		Link

  • Downloaden

    Het volledige arrangement is in de onderstaande formaten te downloaden.

    Metadata

    LTI

    Leeromgevingen die gebruik maken van LTI kunnen Wikiwijs arrangementen en toetsen afspelen en resultaten terugkoppelen. Hiervoor moet de leeromgeving wel bij Wikiwijs aangemeld zijn. Wil je gebruik maken van de LTI koppeling? Meld je aan via info@wikiwijs.nl met het verzoek om een LTI koppeling aan te gaan.

    Maak je al gebruik van LTI? Gebruik dan de onderstaande Launch URL’s.

    Arrangement

    IMSCC package

    Wil je de Launch URL’s niet los kopiëren, maar in één keer downloaden? Download dan de IMSCC package.

    Voor developers

    Wikiwijs lesmateriaal kan worden gebruikt in een externe leeromgeving. Er kunnen koppelingen worden gemaakt en het lesmateriaal kan op verschillende manieren worden geëxporteerd. Meer informatie hierover kun je vinden op onze Developers Wiki.

  • Gebruik
    Weergave
  • Wikiwijs is een dienst van