Als u informatie zoekt over hoe u Docker op Ubuntu installeert, bent u hier aan het juiste adres. Niet alleen dat, maar als bonus zal deze tutorial u ook leren hoe u de basis Docker-commando’s kunt gebruiken om containers uit te voeren en te beheren.
Met behulp van de handige functies van Visual Studio (VS) Code leert u ook hoe u uw SSH-vaardigheden kunt versterken. Laten we beginnen!
Gerelateerd: Een Windows-gebruiker in een Linux-wereld: VS Code en externe SSH
Vereisten
Als u stap voor stap wilt volgen, zorg er dan voor dat u het volgende hebt:
- A fresh install of Ubuntu Server LTS with SSH Enabled (This guide will be using Ubuntu Server LTS 20.04.1)
- A Windows Machine with VSCode installed (This guide will be using Visual Studio Code 1.52.1)
- De officiële SSH-extensie van VSCode geïnstalleerd en verbonden met uw Ubuntu Server LTS-installatie
Docker installeren op Ubuntu
Laten we beginnen met het installeren van Docker op Ubuntu. Op dit punt gaat de tutorial ervan uit dat u op uw lokale Windows-computer bent met VS Code open en verbonden met uw Ubuntu Server via SSH. Leer hoe u deze handige omgeving instelt in het laatste artikel over het gebruik van VS Code en SSH.
In het onderstaande voorbeeld is VSCode op afstand verbonden met Ubuntu met de home-map (in dit geval /home/homelab) geopend als werkruimte:
De werkelijke procedure om Docker te installeren in Ubuntu Server is slechts twee commando’s verwijderd. Ubuntu biedt Docker aan als een installatieoptie in de standaard pakketbeheerder die wordt geleverd bij Ubuntu, bekend als apt.
In het SSH terminalvenster van VS Code, voer de volgende twee commando’s uit om Docker te installeren:
Tijdens de installatie van Ubuntu Server heb je mogelijk de optie gekregen om Docker als een snap te installeren. Als je dit hebt gedaan, verwijder dan eerst het snap-pakket door
sudo snap remove dockeruit te voeren
Je kunt de installatie van docker bekijken in de onderstaande animatie:
Ubuntu is zo vriendelijk om automatisch de service in te schakelen en deze in te stellen om bij het opstarten te starten, dus je bent klaar om Docker te gebruiken!
Het maken en uitvoeren van een Docker-container op Ubuntu
Nu je Docker hebt geïnstalleerd, wat kun je ermee doen? Laten we beginnen met het maken van een Docker-container. Deze handleiding zal een statische webserver opzetten als een goed voorbeeld van een Docker-container. In dit gedeelte zul je:
- Een nieuwe container instellen vanuit het Docker Hub Image Repository om een HTTP-service uit te voeren
- Port Mapping gebruiken om de HTTP-poort binnen de container te koppelen aan je Ubuntu-host
- Bind Mounts instellen om belangrijke gegevens vanuit de container naar je Ubuntu-host te koppelen
- Stel persistentie in voor je container
Als een van de bovenstaande stappen verwarrend klinkt, maak je geen zorgen, we zullen elk van deze stappen één voor één behandelen om je te helpen het proces te begrijpen.
Het downloaden van de Docker-afbeelding
De eerste vraag die je moet stellen is, waar komt deze container vandaan? Laten we een kijkje nemen op de Docker Hub.
A large part of Docker is understanding image repositories. Rather than being distributed like packages, services in Docker get distributed as Docker Images.
A Docker Image is a snapshot of the software that the publisher wants to distribute and the entire filing system! This is analogous to creating .wim image of Windows.
Deze bestandssysteemcaptatie maakt Docker zo populair: de software wordt vastgelegd samen met de volledige werkomgeving. Hierdoor worden problemen geëlimineerd die worden geïntroduceerd door verschillen tussen serveromgevingen.
Één van de meest populaire repositories (en de standaard) voor afbeeldingen is de Docker Hub, ook wel bekend als de officiële Docker-repository. De afbeeldingenrepository is waar je duizenden voorgecreëerde Docker-afbeeldingen kunt downloaden om als containers uit te voeren.
Aangezien deze tutorial een statische webserver opzet, moet je een webserverafbeelding downloaden. De twee meest populaire webservers zijn Apache httpd en Nginx, maar om dingen een beetje te veranderen en je mogelijk kennis te laten maken met een nieuwe webserver, laten we er een gebruiken die Caddy heet.
Caddy is een webserver die bekend staat om zijn eenvoud. Veel geldige serverconfiguraties kunnen worden ingezet met slechts één regel in een bestand. Eenvoudig is goed en dient ook als een goed basiseksemplaar.
- Allereerst moet je de Docker-image vinden. Op je Windows-machine navigeer je naar https://hub.docker.com.
- Voer een zoekopdracht uit naar caddy in de linkerbovenhoek van de pagina. Je zou een pagina moeten zien die lijkt op de volgende:
A benefit (and downside) of Docker Hub is that anyone, even you, can create and upload Docker Images to the site.
Je moet voorzichtig zijn om ervoor te zorgen dat de image die je kiest afkomstig is van een betrouwbare bron. Iedereen kan malware in een image plaatsen als ze dat willen en hun versie naar Docker Hub uploaden.
3. Noteer de naam van de image. In de screenshot hierboven is de naam precies caddy. Je hebt deze naam nodig om de image-naam in de volgende stappen te specificeren.
Het uitvoeren van een container met Docker op Ubuntu
Zodra je de naam van de image die je wilt downloaden weet, is het tijd om deze te downloaden en er een container van te maken.
Het starten van een container vanuit een image vereist één commando. In je SSH-terminal verbonden met je Ubuntu Server, voer je het volgende docker run-commando uit.
Het onderstaande commando controleert of de caddy-image op de lokale machine aanwezig is. Als dat niet het geval is, wordt de image gedownload van Docker Hub, wordt er een container van gemaakt en wordt deze gestart. Het onderstaande commando maakt gebruik van de -p-schakelaar om de luisterpoort 80 van de Ubuntu Server naar poort 80 van de container te mappen. Deze functie wordt poorttoewijzing genoemd.
De meeste Docker Hub-images volgen een naamconventie van <gebruiker>/<imagenaam>. Images die echter als “officieel” zijn gemarkeerd door Docker hebben geen <gebruiker> ervoor staan (zoals caddy hierboven).
plaintext
system: U voert de bovenstaande opdracht uit en krijgt uitvoer zoals hieronder, met de loggegevens van Caddy die rechtstreeks in de terminal worden weergegeven:
Je kunt opmerken dat bijna alle Docker-opdrachten vooraf worden gegaan door
sudo, om de opdrachten als beheerder uit te voeren. Standaard draait de Docker-service alsroot, en alle wijzigingen die je aanbrengt in containers of afbeeldingen moeten als beheerder worden uitgevoerd.
En… je bent klaar! Dat is alles. Ben je niet blij dat je Docker op Ubuntu hebt geïnstalleerd?
Navigeer nu naar http://<jouw-ip> op je Windows-computer en je zou een landingspagina voor Caddy moeten zien. Je kunt dat hieronder zien (het IP-adres van deze handleiding is vervangen door http://homelab-docker):
De caddy-container draait nu, maar je hebt misschien een probleem opgemerkt. Het uitvoeren van die docker-opdracht neemt je opdrachtregel over. Je kunt geen andere opdrachten meer uitvoeren, en als de sessie eindigt, stopt de draaiende container. Laten we dat probleem oplossen door de container in de achtergrond uit te voeren (ook bekend als ontkoppelen van de container).
Docker-containers uitvoeren op de achtergrond
Je hebt nu een draaiende container, maar je opdrachtregel zit vast. Je kunt niets anders doen. Je hebt een betere manier nodig om een container op te starten door deze in de achtergrond uit te voeren als een service. Om dat te doen:
- Stop de huidige container door control+c in te drukken op de opdrachtregel. Hiermee krijg je je opdrachtregel terug.
- Nu, voer dezelfde opdracht opnieuw uit als de vorige, maar dit keer met de
-dparameter zoals hieronder weergegeven. Je zult zien dat Docker een container-ID retourneert en de opdrachtregel aan je teruggeeft.
Beheren van Achtergrondcontainers met Docker-opdrachten
Zodra je een of meer achtergrond-Dockers hebt draaien, moet je ze op de een of andere manier beheren. Docker biedt je hiervoor verschillende opdrachten met behulp van docker container-opdrachten.
sudo docker container list -a: Geeft een lijst van alle containers weer (zowel draaiend als gestopt) en hun statussudo docker container stop <name>: Stop een Docker-container op basis van de naam (of op basis van het ID)sudo docker container start <name>: Start een Docker-container op basis van de naam (of op basis van het ID)sudo docker container prune: Vernietig en verwijder alle gestopte containers
Je kunt al deze bovenstaande opdrachten in context zien in de onderstaande schermafbeelding:
Er zijn veel andere Docker-containeropdrachten om te bekijken, te wijzigen, te inspecteren of zelfs op afstand verbinding te maken met containers op je server. Je kunt ze allemaal bekijken door
sudo docker container --helpuit te voeren.
Zelfs als je nu een webserver in een container hebt ingezet die op de achtergrond draait, heb je nog steeds geen manier om je aangepaste inhoud te hosten. Zoals het nu is, serveert Caddy gewoon de standaardwebpagina.
Laten we nu eens kijken hoe je Docker-images kunt gebruiken met een concept dat bind-koppelingen wordt genoemd om containers te implementeren met betekenisvolle gegevens.
Containergegevens opslaan met bind-koppelingen
Docker werkt volgens het concept van images (en de containers die ze genereren) als wegwerpbaar of vluchtig. Als er een update is voor de Caddy-software, update je de service niet, maar gooi je het hele kind met het badwater weg en gebruik je een volledig nieuwe image vanaf nul.
De voordelen van het weggooien en opnieuw maken van containers op deze manier zijn aanzienlijk. Instabiliteiten in software worden na verloop van tijd geïntroduceerd door voortdurend een (potentieel) jaren oude software bij te werken. Door elke keer een nieuwe image te gebruiken, biedt Docker je een stabiele, betrouwbare, (vermoedelijk) geteste basis bij elke update.
Dit concept komt overeen met het gebruik van een schone installatie van Windows telkens wanneer je je Windows-toepassingssoftware bijwerkt. Geen leuk idee op Windows, maar uiterst toepasbaar in Docker.
De wegwerpmethode heeft echter een duidelijk probleem. Je wilt niet dat essentiële gegevens worden weggegooid wanneer je huidige service wordt weggevaagd. Docker lost dit probleem op met een concept dat bind-koppelingen wordt genoemd.
Laten we nu eens verkennen hoe je een bind-koppeling voor een container kunt maken.
Het maken van de mappenstructuur en het opschonen
Voordat je bind-koppelingen kunt gebruiken, moet je een locatie creëren waar deze gegevens kunnen worden opgeslagen. In deze tutorial zal een map worden aangemaakt in je thuismap. Doe dit in VS Code terwijl je nog steeds verbonden bent met je Ubuntu Server:
- Rechtsklik in een leeg gebied van het Verkenner-paneel van VS Code Explorer en kies nieuwe map.
2. Noem de nieuwe map containers/caddy/files.
De mapnamen zijn aan jou, zolang ze correct gedefinieerd zijn in de aankomende docker-opdracht. Door een schuine streep te gebruiken, interpreteert VS Code dit als het maken van drie mappen. De files-map is een submap van caddy, en caddy is een submap van containers. Je hoeft deze mapstructuur niet te gebruiken, maar de structuur is logisch wanneer je meerdere containers op dezelfde server hebt.
Als dit nog niet eerder is gedaan, stop dan en verwijder alle containers die je eerder hebt gemaakt met het volgende:
Je kunt deze opdracht zien in de onderstaande schermafbeelding:
Implementatie van een Caddy-container met Bind Mounts
Je hebt nu de mapstructuur gebouwd op de Ubuntu Server. Het is tijd om een Caddy-container te maken met bind mounts.
- Voordat je te ver gaat, zoek eerst uit waar de container waarmee je werkt persistente gegevens opslaat. Die locatie is anders, afhankelijk van wie de Docker-image heeft gemaakt en met welk doel het dient.
Je beste optie om te achterhalen waar persistente gegevens zijn opgeslagen, is om de documentatie binnen de Docker Hub voor de betreffende image te controleren. Voor Caddy kun je de documentatie hier vinden:
1. Start de container met behulp van onderstaand commando. De -v ~/containers/caddy/files:/usr/share/caddy-parameter koppelt het pad vóór de dubbele punt (~/containers/caddy/files) aan de map binnen de container (/usr/share/caddy). Dit werkt uiterst vergelijkbaar met het poortkoppelingscommando: behalve dat je een map koppelt in plaats van een poort. Dit type commando wordt een Bind Mount genoemd.
De tilde (
~) in de bovenstaande code verwijst naar de home-map. Voor dit artikel is dat equivalent aan/home/homelab.
2. Open een browser en ga terug naar het http-adres van je server. Je zult merken dat de server nu een 404-pagina serveert. Dit is te verwachten omdat je momenteel geen index.html-bestand hebt in ~/containers/caddy/files.
3. Maak een index.html-bestand aan in ~/containers/caddy/files op de Ubuntu-server in het VS Code Explorer-venster dat er als volgt uitziet:
4. Ga naar het HTTP-adres van je server en bevestig dat de container nu je nieuwe index.html-pagina serveert.
Je kunt dit alles zien in de volgende animatie:
In tegenstelling tot de dockerbeheeropdrachten, hebben de bestanden die je maakt (zoals index.html) geen beheerdersrechten nodig. Dit komt doordat jij eigenaar bent van de inhoud die de caddy-server serveert, aangezien ze in je thuismap staan.
Valideren van de bind-mount
Geweldig! Je gebruikt niet alleen een volledig nieuwe Docker-container, maar die container serveert ook inhoud die lokaal is opgeslagen in je thuismap! Dit kun je bewijzen door het volgende uit te voeren:
- Stop en verwijder de draaiende container. Deze stap verwijdert alles, inclusief dat index.html-bestand, als je geen bind mounts gebruikte.
2. Maak een gloednieuwe container.
3. Verifieer dat de nieuwe container nog steeds het index.html-bestand serveert op het http://<jouw server>-adres.
Het maken van persistente Docker-containers
A container isn’t that useful if it stops when the server reboots. By default, that’s what is going to happen if you don’t make it happen. To prevent this, let’s generate a new caddy container again but this time once that restarts when the Docker host, Ubuntu in this case, restarts.
- Stop en verwijder alle draaiende containers.
2. Start de caddy-container opnieuw met de parameter --restart always, om deze nieuwe container in te stellen om te starten met de host bij het opnieuw opstarten. Met de vlag --restart always gedraagt je container zich nu als een echte service: hij start automatisch bij het opstarten.
3. Start de server opnieuw op.
4. Verifieer nu dat de nieuwe container wordt gestart en nog steeds het index.html-bestand serveert op het http://<jouw server>-adres.
Je kunt de volgende toegepaste opdrachten hieronder zien:
Verdergaan
Op dit punt zou je een werkende Docker-omgeving moeten hebben en een basisbegrip van images en containers. Je kunt containers ophalen, starten, stoppen en basisbeheer van je containers uitvoeren. Je hebt ook succesvol een draaiende webservice-container gemaakt met behulp van bind mounts en poortmapping.
Er valt nog veel te bespreken over Docker: Blijf afgestemd op deze ruimte, aangezien het volgende artikel ingaat op geavanceerd Docker-beheer met behulp van Docker Compose.