Versterk je vaardigheden met deze Docker Compose tutorial

Handleidingen
Docker

Als je je afvraagt hoe je reproduceerbare Docker-containers kunt maken met Docker Compose, ben je hier aan het juiste adres. In deze stapsgewijze Docker Compose handleiding leer je hoe je eenvoudige containers kunt maken, poorten kunt koppelen met Docker Compose tot complexe multi-container scenario’s.

Ben je er klaar voor? Laten we beginnen!

Vereisten

Als je stap voor stap wilt volgen, zorg er dan voor dat je het volgende hebt:

  1. A fresh install of Ubuntu Server LTS with SSH Enabled. This guide will use Ubuntu Server LTS 20.04.1 as the Docker host machine.
  2. A computer with VS Code installed (optional). This guide will use Visual Studio Code 1.52.1 to SSH to the Docker host and run commands.
  3. De officiële SSH-extensie van VS Code geïnstalleerd en verbonden met de Docker-host. (optioneel)

Gerelateerd:VS Code en Remote SSH

Wat is Docker Compose?

Enkele commando’s kunnen erg lang worden in Docker. Neem het onderstaande als voorbeeld. Dit voorbeeld maakt een container voor een softwaretoepassing genaamd bookstack.

docker create \
   --name=bookstack \
   -e PUID # UID van gebruiker om eigendom van toepassing/bestanden over te nemen \
   -e PGID # GID van gebruiker om eigendom van toepassing/bestanden over te nemen \
   -e DB_USER # De databasegebruiker \
   -e DB_PASS # Het database-wachtwoord \
   -e DB_HOST # De databasehost \
   -e DB_DATABASE # De te gebruiken database \
   -e APP_URL # De URL waarop uw toepassing toegankelijk zal zijn (vereist voor de juiste werking van de omgekeerde proxy) \
   -v /host/path/to/config:/config # Locatie van geüploade gegevens \
   -p 80:80/tcp # Web-UI-poort \
   --restart unless-stopped \
   linuxserver/bookstack:version-v0.31.4

Naarmate de complexiteit van een Docker-omgeving toeneemt, neemt ook het aantal vlaggen en voorwaarden toe dat nodig is voor een werkende containerconfiguratie. De Docker-opdrachtregel wordt al snel omslachtig en moeilijk op te lossen, vooral wanneer meerdere containerconfiguraties in het spel komen.

Docker Compose is een manier om reproduceerbare Docker-containers te maken met behulp van een configuratiebestand in plaats van extreem lange Docker-opdrachten. Door een gestructureerd configuratiebestand te gebruiken, zijn fouten gemakkelijker op te sporen en zijn containerinteracties gemakkelijker te definiëren.

Docker Compose wordt snel onmisbaar bij het omgaan met containerafhankelijkheden of omgevingen met meerdere containers.

Docker Compose is een fantastische manier om kennis te maken met Infrastructure as Code zonder de complexiteit van gedistribueerde systemen zoals Kubernetes.

Docker Compose maakt gebruik van een configuratiebestandsstructuur genaamd YAML. YAML is vergelijkbaar met JSON of HTML in die zin dat YAML een gestructureerde, machine-leesbare taal is. YAML richt zich specifiek op leesbaarheid voor mensen terwijl het toch die gestructureerde kracht behoudt.

YAML heeft echter het nadeel dat tabs en andere witruimten significant zijn en correct moeten worden opgemaakt. VS Code neemt veel van dit zware werk voor je uit handen en dat is ook de reden waarom je veel voorbeelden zult zien die in VS Code zijn gedaan.

Installatie van Docker Compose

Laten we nu aan de slag gaan. Als je verbonden bent met je Docker-host, is het tijd om Docker Compose te installeren.

Docker Compose is een apart pakket van de Docker-runtime. Maar het installeren van Docker Compose zal ook de Docker-runtime installeren, dus je slaat twee vliegen in één klap!

Om Docker Compose en de Docker-runtime te installeren, voer je de volgende twee commando’s uit.

# Werk de softwarelijst bij (ook wel bekend als een repository) en installeer vervolgens Docker Compose
# met eventuele benodigde afhankelijkheden. De -y vlag wordt gebruikt om de bevestiging over te slaan
sudo apt update -y
sudo apt install docker-compose -y
The installation command for Docker Compose

Eenmaal geïnstalleerd, moet je nu een mapstructuur maken om containers op te slaan.

Het maken van een mapstructuur voor Docker Compose

Voordat je een container kunt maken met Docker Compose, moet je eerst een map maken om containers op te slaan. Je moet niet alleen een mapstructuur maken om containers op te slaan, maar je zult merken dat verschillende Docker-opdrachten gevoelig zijn voor de locatie van verschillende configuratiebestanden; Docker Compose is niet anders.

Het belangrijkste onderdeel van Docker Compose is het configuratiebestand genaamd docker-compose.yaml. Dit configuratiebestand, zoals hierboven uitgelegd, bepaalt hoe de Docker-runtime een container moet bouwen.

Wanneer je Docker Compose uitvoert, zal de opdracht naar het configuratiebestand zoeken in dezelfde map als waar de opdracht wordt uitgevoerd. Vanwege deze vereiste is het altijd het beste om een aparte map te maken bij het uitvoeren van Docker Compose.

Er mag slechts één Docker Compose-configuratiebestand per map zijn.

Om het maken van een Docker-container met Docker Compose te demonstreren, maak eerst een mapstructuur om de toekomstige container en het configuratiebestand op te slaan met behulp van een kleine fileserver genaamd Caddy.

Caddy is een fileserver, vergelijkbaar met apache httpd of nginx, maar geschreven in de Go-taal. Caddy is specifiek ontworpen voor gebruiksgemak (en zal automatisch een index.html-bestand genereren of serveren) zonder configuratie. Deze combinatie maakt Caddy een goede keuze voor beginners.

Als je bent ingelogd op je Docker host, maak dan de mapstructuur als volgt aan:

  1. In je thuismap, maak een map genaamd containers aan. Deze map zal een goede plek zijn voor deze en andere containers.
  2. Maak binnen de containers-map een submap genaamd caddy aan. Deze map zal het Docker Compose-configuratiebestand en de Caddy-container zelf bevatten.
  3. Tenslotte, binnen de containermap, caddy, maak een leeg tekstbestand genaamd docker-compose.yaml aan dat het Docker Compose-configuratiebestand zal worden.

Met de mapstructuur en het Docker Compose-configuratiebestand aangemaakt, kun je nu beginnen met het invullen van dat configuratiebestand met een Docker Compose-configuratie.

Het maken van een Docker Compose-configuratiebestand

Op zijn meest basisvorm ziet een docker-compose.yaml-bestand voor de caddy-container er als volgt uit. In je favoriete Linux teksteditor of met VS Code, kopieer en plak de onderstaande code in het eerder aangemaakte Docker Compose-configuratiebestand.

version: "3.7"
services:
  caddy:
    container_name: "caddy"
    image: "caddy:latest"
    ports:
      - "80:80"

Laten we elk van de getoonde opties doorlopen:

  • version specificeert de versie van het docker-compose-bestand. Elke nieuwe definitie van Docker Compose bevat breaking changes naar de specificatie. Daarom is de versie belangrijk, zodat Docker Compose kan bepalen welke functies het moet gebruiken. Versie 3.7 is de nieuwste versie die wordt ondersteund door Ubuntu 20.04.1 LTS.

De volledige specificatie voor Docker Compose 3.x is hier te vinden. De gelinkte documentatie vermeldt elke optie die je kunt gebruiken binnen Docker Compose

  • services bevatten de specificaties voor de daadwerkelijke containers. Je kunt meerdere containers in deze sectie definiëren.
  • caddy is de naam van de eerste container (dit is puur ter referentie).
  • container_name bepaalt de daadwerkelijke naam die aan de container wordt gegeven door Docker en moet uniek zijn.
  • image is de naam van de afbeelding. In dit geval is caddy gedefinieerd vanaf de Docker Hub. De naam of het nummer na de tag, gescheiden door een dubbele punt, is de versie.

Port Mapping

Met name die laatste optie verdient een speciale vermelding:

ports:
  - "80:80"

In Docker Compose, de ports directive stelt je in staat om één of meer koppelingen van de host naar de container in te stellen. Bijvoorbeeld, hierboven heb je poort 80 op de host gekoppeld aan poort 80 op de container. Het is echter niet nodig om het poortnummer overeen te laten komen. Het voorbeeld hieronder koppelt bijvoorbeeld poort 8800 op de host aan poort 80 in de container.

ports:
  - "8800:80"

Je kunt ook meerdere poorten definiëren zoals hieronder.

ports:
  - "80:80"
  - "443:443"

Dit zou beide poorten 80 en 443 naar de host mappen (een gebruikelijke configuratie voor webservers, om zowel HTTP als HTTPS te bedienen).

De Docker-image-maker definieert beschikbare poorten op het moment van creatie. Zorg ervoor dat je de documentatie van de image die je gebruikt op Docker Hub of de website van de maintainer controleert voor mappable poorten. Het heeft geen zin om een poort te mappen als de poort niet in gebruik is!

Met dat in gedachten, laten we eens kijken naar het daadwerkelijk uitvoeren van de container.

De Container Uitvoeren

Op dit moment zou je het docker-compose.yaml-bestand moeten hebben binnen je ~\containers\caddy-map. Nu is het tijd om de Caddy-container te maken en te starten.

Voer het volgende commando uit op je terminal, waarmee de Docker-containers worden gestart die gedefinieerd zijn in het docker-compose.yaml-bestand.

# Dit commando moet worden uitgevoerd in dezelfde map als het bestand. De -d vlag voert
# het commando *detached* uit, waardoor de container op de achtergrond wordt gestart
sudo docker-compose up -d

Je zult misschien opmerken dat je de locatie van het docker-compose.yaml-bestand niet hoefde op te geven bij het uitvoeren van sudo docker-compose up -d. Docker Compose verwacht dat je alle commando’s uitvoert binnen de map die het docker-compose.yaml-bestand bevat, aangezien veel commando’s relatief zijn aan die map.

Controleer nu of de container actief is door naar http://<jouw ip> te navigeren. Deze handleiding gebruikt http://homelab-docker ter referentie.

Je kunt dit proces zien gebeuren in VS Code terwijl je SSH hebt ingeschakeld op de Docker-host in de onderstaande animatie:

Demonstrating a container created with Docker Compose

Succes! Je hebt nu succesvol Docker Compose gebruikt om een container te starten vanuit een configuratiebestand. Met die eerste belangrijke stap gezet, laten we eens kijken hoe je de status van je container beheert.

Opdrachten om losgekoppelde containers te beheren

In het vorige gedeelte heb je de caddy-container gestart met de -d-vlag. Hierdoor werd een container in een losgekoppelde toestand uitgevoerd. Wanneer een container in een losgekoppelde toestand is, blijft de container op de achtergrond actief. Maar dit levert een probleem op: hoe beheer je die container als je niet langer directe controle hebt?

Om dit probleem op te lossen, heeft Docker Compose een reeks commando’s die containers beheren die zijn gestart met een docker-compose.yaml-bestand:

  • docker-compose restart wordt gebruikt om een container die momenteel actief is opnieuw te starten. Dit verschilt van het daadwerkelijk opnieuw uitvoeren van docker-compose up -d. Het herstartcommando zal eenvoudigweg een bestaande container opnieuw starten, het docker-compose up -d commando opnieuw uitvoeren en de container opnieuw maken vanaf nul (indien het configuratiebestand is gewijzigd).
  • docker-compose stop zal een actieve container stoppen zonder de container te vernietigen. Op dezelfde manier zal docker-compose start de container opnieuw opstarten.
  • docker-compose down zal de actieve containers stoppen en ze ook vernietigen. Hier komt het gebruik van bind mounts of volumes in het spel (lees hieronder meer).
  • docker-compose pull haalt de huidige versie van de docker-image (of images) op van het repository. Als je de latest-tag gebruikt, kun je vervolgen met docker-compose down && sudo docker-compose up -d om de container te vervangen door de nieuwste versie. Het gebruik van docker-compose pull is een handige manier om containers snel bij te werken met minimale downtime.
  • docker-compose logs toont de logs van de actieve (of gestopte) container. Je kunt ook individuele containers aanspreken (als er meerdere containers gedefinieerd zijn in het compose-bestand) met docker-compose logs <container naam>.

A full list of docker-compose commands can be seen by running docker-compose with no additional arguments or referenced here in the documentation.

Nu je een actieve container hebt, laten we eens kijken naar het gebruik van lokaal opgeslagen inhoud op je machine.

Het creëren van Bind Mounts in Docker Compose

Bind mounts zijn hoe Docker belangrijke gebruikersgegevens toewijst aan lokale opslag op uw server. Om te beginnen, genereer wat inhoud voor de container om te hosten:

  1. Op de Docker-host, binnen de map ~/containers/caddy, maak een nieuwe map genaamd files.

2. Maak een nieuw bestand genaamd index.html binnen de map ~/containers/caddy dat er als volgt uitziet. Dit zal de hoofdpagina zijn die de Caddy-webserver zal serveren. 

<body><h2>hello world!</h2></body>

3. Pas uw Docker Compose-configuratiebestand aan zodat het er als volgt uitziet. Het voorbeeldbestand hieronder voegt de volumes-sectie toe en wijst een bind mount toe aan de zojuist gemaakte map files om deze beschikbaar te maken voor de container. 

version: "3.7" services: caddy: container_name: "caddy" image: "caddy:latest" ports: - "80:80" volumes: #de ./ verwijst naar een map relatief aan het docker-compose bestand - "./files:/usr/share/caddy"

4. Voer opnieuw docker-compose up -d uit. Docker Compose zal nu herkennen dat het bestand is gewijzigd en uw container opnieuw maken.

5. Navigeer met een browser naar de pagina van de container en u zou nu de “Hallo wereld!” pagina moeten zien.

U kunt het volgende zien in de onderstaande animatie:

Creating a bind mount using Docker Compose

U host nu inhoud die lokaal op uw machine is opgeslagen! Maar wat als uw inhoud op een externe bron staat, zoals een netwerkshare?

Het gebruik van Docker Compose met Docker Volumes

Zodra je een eenvoudige container hebt gemaakt met Docker Compose, heb je waarschijnlijk die container nodig om ergens anders bestanden te kunnen openen, misschien op een netwerkshare. Als dat het geval is, kun je de container configureren om Docker-volumes te gebruiken, rechtstreeks in je Docker Compose-configuratiebestand.

Voor demonstratiedoeleinden zal deze handleiding een Network File Share (NFS) server aanmaken op de Docker-host. Het lokaliseren van lokale inhoud als een NFS-mount heeft buiten demonstratie geen praktisch doel. Als je een NFS-volume zou aankoppelen, zal dit over het algemeen van een externe bron zijn zoals een NAS of een externe server.

Richt een NFS-share in

Als je nog geen NFS-share hebt opgezet, bouw er dan nu een op op de Docker-host voor deze zelfstudie. Doe het volgende:

  1. Installeer het NFS-server pakket door apt install nfs-kernel-server -y uit te voeren.

2. Voeg de container toe als een NFS-export (vergelijkbaar met een Windows CIFS-share) door het volgende uit te voeren. 

# Voeg een regel toe aan het /etc/exports-configuratiebestand om een NFS-share te maken voor # /home/homelab/containers. Deze share is alleen blootgesteld aan localhost (om # te voorkomen dat andere computers toegang hebben) echo '/home/homelab/containers localhost(rw,sync,no_root_squash,no_subtree_check)' | sudo tee -a /etc/exports # Herstart de NFS-server met de nieuwe configuratie sudo systemctl restart nfs-kernel-server

3. Controleer nu of de host de NFS-share blootstelt door het commando showmount -e localhost uit te voeren. Dit commando toont eventueel blootgestelde NFS-shares en wie toegang heeft.

In de onderstaande schermafbeelding kun je zien dat /home/homelab/containers is blootgesteld, maar alleen voor de lokale computer (die hetzelfde is als de server waarop de Docker-host draait).

Creating a NFS share in Ubuntu 20.04

Als je de map /home/<gebruikersnaam>/containers in de uitvoer ziet, is de NFS-share geconfigureerd.

Het definiëren van een Docker Genoemde Volume

Nadat je de NFS-share hebt gemaakt, moet je Docker nu vertellen hoe toegang te krijgen tot die share. Met Docker Compose kun je dat doen door een genoemd volume te definiëren in het Docker Compose-configuratiebestand.

A named volume is a way for Docker to abstract network-based file shares. Network file sharing comes in all sorts of shapes and sizes these days: CIFS (windows) shares, NFS (Linux) shares, AWS S3 Buckets, and more. By creating a Named Volume, Docker does the hard part of figuring out how to talk to the network share and lets the container just treat the share as if it is local storage.

Om een genoemd volume te maken:

  1. Open het Docker Compose-configuratiebestand (docker-compose.yaml). Als je het volgt, moet het bestand zich bevinden in de map ~/containers/caddy.

2. Voeg binnen het Docker Compose-configuratiebestand een volumes-sectie toe na de services-sectie. Je configuratiebestand moet er als volgt uitzien. De volumes-sectie maakt een genoemd volume genaamd MyWebsite. Binnen dat genoemde volume worden de benodigde parameters (zoals IP, NFS-instellingen en pad) gespecificeerd. De volumes-parameter binnen de services-sectie wordt ook aangepast om naar het naamvolume te verwijzen in plaats van naar een lokale map.

version: "3.7"
 services:
   caddy:
     container_name: "caddy"
     image: "caddy:latest"
     ports:
       - "80:80"
     volumes:
       - "MyWebsite:/usr/share/caddy"
 volumes:
   MyWebsite:
     driver_opts:
       type: "nfs"
       o: "addr=localhost,nolock,soft,rw"
       device: ":/home/homelab/containers/caddy/files"

3. Zodra je het benoemde volume hebt gedefinieerd dat naar de NFS-share wijst in het Docker Compose-configuratiebestand, voer je docker-compose up -d uit om de container te maken en te starten. Als alles goed gaat, zou de container en de website weer online moeten komen.

Setting NFS client settings within Docker Compose in VS Code

4. Ga opnieuw naar de pagina van de container. De inhoud van index.html zou moeten verschijnen alsof het bestand lokaal werd gemount. In werkelijkheid wordt dat bestand echter via de NFS-server in het netwerk gemount.

Demonstrating access to the index.html file through an NFS share in Docker

Aangezien je nu externe Docker-volumes kunt mounten in Docker Compose, kun je allerlei soorten netwerkopslag naar je containers brengen. Docker Compose kan echter meer dan alleen individuele containers of volumes definiëren. Laten we duiken in complexere, multi-container scenario’s.

Deze tutorial zal geen gebruik meer maken van de caddy-container, dus je kunt de container verwijderen met docker-compose down.

Het definiëren van meerdere containers in Docker Compose

De meeste Docker-containers werken niet geïsoleerd. Docker-containers hebben vaak services afhankelijkheden zoals databases of afzonderlijke webservices die communiceren via een API.

Met Docker Compose kun je containers groeperen die binnen één bestand zijn gedefinieerd. Door meerdere containers in één bestand te definiëren, kunnen containers communiceren tussen afhankelijke services en wordt de organisatie van complexe containerlay-outs vereenvoudigd.

Om zo’n scenario te demonstreren, laten we een populaire wiki-toepassing genaamd BookStack opzetten.

is een populaire wikisoftware die bekend staat om zijn gebruiksgemak en hiërarchische lay-out (in tegenstelling tot een platte lay-out, zoals ).

, net als veel webapplicaties, vereist een aparte database om goed te functioneren, evenals de informatie die nodig is om met de database te communiceren. Het opzetten van zo’n situatie is waar Docker Compose in uitblinkt.

Maak het Docker Compose-configuratiebestand

heeft geen intern onderhouden Docker-image, echter, onderhoudt namens een betrouwbaar . Hoewel de documentatie op de Docker-hubsite een aanbevolen Docker Compose-configuratiebestand heeft, zal deze tutorial een nieuw configuratiebestand bouwen terwijl de concepten worden uitgelegd.

Op de Docker-host:

  1. Ten eerste, maak een map voor . Als je de tutorials uit de vorige sectie hebt gevolgd, zou je een map <~/containers> moeten hebben. Maak daar een map genaamd in.

2. Maak vervolgens een leeg Docker Compose-configuratiebestand genaamd binnen de map .

Creating the folder structure for Bookstack in VS Code

3. Open nu het Docker Compose-configuratiebestand en definieer twee containers: de bookstack-container en de bookstack_db (mariadb)-container.

version: "3.7"
 services:
   bookstack:
     container_name: "bookstack"
     image: "ghcr.io/linuxserver/bookstack"
     ports:
       - "8080:80"
     volumes:
       - "./files:/usr/share/caddy"
     depends_on:
       - "bookstack_db"
   bookstack_db:
     container_name: "bookstack_db"
     image: "mariadb"
     volumes:
       - "./db:/var/lib/mysql"

Tot nu toe maakt dit `docker-compose.yaml`-bestand voornamelijk gebruik van concepten die al zijn geïntroduceerd: je hebt twee services (`bookstack` en `bookstack_db`), beide met afbeeldingen en bind mounts. De bookstack-container heeft een poortkoppeling van hostpoort 8080 naar interne poort 80.

Gezien de extreem lage overhead van Docker-containers is het gebruikelijk om voor elke webtoepassing een afzonderlijke databasecontainer te definiëren. Op deze manier kan er een grotere scheiding van taken plaatsvinden. Dit is aanzienlijk anders dan traditionele databaseopstellingen, waarbij een enkele database-installatie mogelijk honderden webtoepassingen bedient.

Een nieuwe optie die je in het bovenstaande bestand kunt zien, is de `depends_on`-opdracht. Deze opdracht vertelt Docker in welke volgorde de containers moeten starten. Door de `depends_on`-opdracht te definiëren, vertel je Docker dat de `bookstack_db`-container eerst moet starten.

Opzetten van communicatie tussen containers met omgevingsvariabelen

Deze configuratie in het laatste gedeelte is nog niet volledig. Hoewel je twee services (containers) hebt gedefinieerd, communiceren ze niet met elkaar! De `bookstack`-container weet niet hoe hij moet communiceren met de `bookstack_db`-container. Laten we dat oplossen met behulp van omgevingsvariabelen.

Omgevingsvariabelen zijn de meest gebruikelijke manier om variabelen aan Docker-containers te verstrekken. Dit zijn variabelen die worden opgegeven bij runtime (of gedefinieerd in het `docker-compose.yaml`-configuratiebestand) om informatie te verstrekken over wat de container moet doen.

Omgevingsvariabelen worden gedefinieerd door de persoon die het Docker-image maakt. Ze zullen verschillen afhankelijk van het Docker-image dat u gebruikt, en u moet verwijzen naar de documentatie van de maker over welke omgevingsvariabelen te gebruiken.

Er zijn twee methoden om omgevingsvariabelen te definiëren; direct in het docker-compose.yaml-bestand zelf of als een apart bestand.

A separate file is, typically, the recommended method, especially if variables contain sensitive data such as passwords. A docker-compose.yaml file is designed to be shared or even uploaded to a public-facing GitHub repo. Having a separate file for sensitive data reduces the chance of an accidental security breach.

Op de Docker-host, maak nu twee omgevingsvariabelen aan; één voor de bookstack-container en één voor de bookstack_db-container.

  1. Maak een nieuw bestand aan in de ~/containers/bookstack-map met de naam bookstack.env met de volgende inhoud: 
APP_URL is the IP address or hostname of your server. This article is using homelab-docker
 APP_URL=http://homelab-docker:8080
 DB_HOST is the container name you gave your container
 DB_HOST=bookstack_db
 DB_USER is defined in the bookstack_DB environment file
 DB_USER=bookstack_user
 DB_PASS is also defined in the bookstack_DB environment file
 DB_PASS=MySecurePassword
 DB_DATABASE is the name of the database within mariadb
 DB_DATABASE=bookstack

2. Maak een nieuw bestand aan in de ~/containers/bookstack-map met de naam bookstack_db.env en voeg de volgende inhoud toe: 

The root password for our database, keep it secret, keep it safe
 MYSQL_ROOT_PASSWORD=MySecureRootPassword
 The database bookstack will be using
 MYSQL_DATABASE=bookstack
 the user bookstack will be using
 MYSQL_USER=bookstack_user
 the password bookstack will be using
 MYSQL_PASSWORD=MySecurePassword

3. Als goede praktijk zorgt u er nu voor dat beide env-bestanden niet leesbaar zijn voor andere gebruikers. 

chmod 600 bookstack.env bookstack_db.env

U moet de leestoegang wijzigen omdat zowel de bestanden bookstack.env als bookstack_db.env gevoelige gegevens bevatten.

4. Werk het ~/containers/bookstack/docker-compose.yaml-Docker Compose-bestand bij om te verwijzen naar deze twee omgevingsbestanden zoals hieronder weergegeven. 

version: "3.7"
 services:
   bookstack:
     container_name: "bookstack"
     image: "ghcr.io/linuxserver/bookstack"
     ports:
       - "8080:80"
     volumes:
       - "./files:/usr/share/caddy"
     depends_on:
       - "bookstack_db"
     env_file:
       - "./bookstack.env"
   bookstack_db:
     container_name: "bookstack_db"
     image: "mariadb"
     volumes:
       - "./db:/var/lib/mysql"
     env_file:
       - "./bookstack_db.env"

5. Start nu de bookstack– en bookstack_db-containers met Docker Compose. 

sudo docker-compose up -d

U kunt elk van de genoemde stappen in deze sectie uitvoeren in VS Code hieronder.

Setting up environment variables and the Docker Compose file with VS Code

Monitoring Docker Compose Logs

De Docker-engine werkt samen met Docker Compose om verschillende taken op de achtergrond uit te voeren. Het is handig om te kunnen controleren wat er gebeurt, vooral bij het werken met meerdere containers tegelijk.

Om bijvoorbeeld de bookstack-container te controleren, gebruik je het logs-commando. In deze handleiding, zodra je ziet dat de logs [services.d] klaar tonen, kun je naar de bookstack-URL gaan.

sudo docker-compose logs bookstack
Using the docker-compose logs command
The bookstack welcome screen. Default login is [email protected]/password

Op dit moment zou je een volledig functionerende wiki moeten hebben die binnen zijn eigen container draait, met zijn eigen database, allemaal binnen Docker!

Zolang je de mappen bookstack en bookstack_db hebt, kun je je bookstack-omgeving vanaf nul opnieuw maken.

Docker Compose en Netwerken

Tot nu toe heb je niet veel geleerd over de communicatie- en netwerkaspecten van hoe containers samenwerken. Laten we dat veranderen.

Wanneer je meerdere containers maakt binnen een enkel docker-compose.yaml-bestand zoals je hebt gedaan in de vorige secties, worden ze allemaal toegewezen aan hetzelfde netwerk (gewoonlijk genaamd naam-van-oudermap_default).

Je kunt het netwerk zien dat is gemaakt voor de containers wanneer je docker-compose up -d uitvoert zoals hieronder wordt getoond.

The default network created with docker-compose comes up

Wanneer alle containers binnen hetzelfde netwerk worden toegewezen, maakt Docker intern DNS-vermeldingen voor ze aan. Daarom verwees je in het vorige voorbeeld naar je database als bookstack_db in de omgevingsvariabelen. Die naam bookstack_db is eigenlijk een DNS-vermelding die verwijst naar het IP-adres van de databasecontainer.

Je hoeft ook niet afhankelijk te zijn van Docker Compose om netwerken voor je te genereren. Je kunt handmatig interne of externe netwerken definiëren. Het handmatig definiëren van netwerken is handig wanneer je een container hebt die moet communiceren met een andere container in een aparte docker-compose.yaml bestand. Je kunt de poorten openstellen of je kunt een netwerk creëren waar ze zich allebei bij kunnen aansluiten!

Houd er rekening mee dat wanneer je expliciet netwerken begint te definiëren, je ook het standaardnetwerk expliciet moet definiëren. Docker Compose stopt met het automatisch aanmaken van dat netwerk zodra je begint met het definiëren van de netwerken

Wijzig nu het bookstack docker-compose.yaml bestand om een extern gemaakt netwerk op te nemen.

  1. Maak het externe netwerk aan met docker network create my_external_network.

2. Definieer het externe netwerk in docker-compose.yaml:

version: "3.7"
 services:
   bookstack:
     container_name: "bookstack"
     image: "ghcr.io/linuxserver/bookstack"
     ports:
       - "8080:80"
     volumes:
       - "./files:/usr/share/caddy"
     depends_on:
       - "bookstack_db"
     env_file:
       - "./bookstack.env"
     networks:
       - "my_external_network"
       - "bookstack_default"
   bookstack_db:
     container_name: "bookstack_db"
     image: "mariadb"
     volumes:
       - "./db:/var/lib/mysql"
     env_file:
       - "./bookstack_db.env"
     networks:
       - "bookstack_default"
 networks:
   bookstack_default:
   my_external_network:
     external: true

3. Voer docker-compose up -d uit om de containers opnieuw aan te maken. Jouw twee containers zijn nu verbonden met twee netwerken zoals hieronder wordt weergegeven.

A highlight of the networks defined within a docker-compose file

De bookstack-container is nu ook verbonden met een extern gedefinieerd netwerk. Dit stelt je in staat om een andere container te maken die het HTTP-verkeer van bookstack omzet in HTTPS voordat het Docker verlaat (ook wel een reverse-proxy genoemd).

Het instellen van een specifieke gebruiker om een container uit te voeren

Standaard draaien alle Docker-containers als een geïsoleerde root-gebruiker. Dit komt overeen met het draaien van een virtuele machine ingelogd als de standaard beheerdergebruiker. Hoewel dit doorgaans geen probleem is, zijn er beveiligingszorgen als de sandbox wordt gecompromitteerd.

Het andere probleem bij het draaien als root is bestandsmachtigingen. Je zult merken dat als je de db-map binnen de bookstack-map probeert te verwijderen, je dat eigenlijk niet kunt; de inhoud is eigendom van root.

Hoewel de meeste images het niet waarderen om als niet-rootgebruiker te draaien, bieden linuxserver.io-images in het bijzonder een omgevingsvariabele om de gebruiker die binnen de container draait in te stellen. Dit kan worden gedaan door UID=1000 en GID=1000 toe te voegen aan de bookstack.env-configuratie.

1000:1000 is de standaard gebruikers-ID en groep voor de eerste gebruiker in Ubuntu (wat je misschien niet bent). Je kunt meer lezen over gebruikers-ID’s en groeps-ID’s op Gerelateerd: Een Windows-persoon in een Linux-wereld: Gebruikers en Bestandsmachtigingen)

Je kunt ook een UID en GID afdwingen met de user-parameter in docker-compose, maar dit wordt niet aanbevolen omdat de meeste containers zich niet goed gedragen wanneer ze worden gedwongen om als een andere gebruiker te draaien

Het instellen van het herstartbeleid

Als je wilt dat containers die zijn gebouwd met Docker Compose opnieuw worden gestart bij een storing, gebruik dan het restart-beleid door een restart: <option>-parameter toe te voegen onder de containerinstellingen in docker-compose.yaml. 

restart: "no"
restart: always
restart: on-failure
restart: unless-stopped

Het toevoegen van deze parameter zorgt ervoor dat containers automatisch opnieuw worden gestart bij een storing om de uptime te behouden in geval van onverwachte stroomstoringen.

Het handmatig instellen van DNS-vermeldingen voor containers

Net als bij Windows en Linux heeft Docker ook een “hosts-bestand”. Door de extra_hosts-parameter in een configuratiebestand te gebruiken, kun je afdwingen dat een host naar een specifiek IP-adres wordt omgezet. Dit kan handig zijn wanneer je DNS-beperkingen hebt, zoals split DNS of een tests erver waarmee je tijdelijk wilt communiceren.

extra_hosts:
  - "somehost:x.x.x.x"
  - "otherhost:x.x.x.x"

Opdrachten uitvoeren

Zodra de container is gestart, kun je commando’s uitvoeren binnen de container met behulp van het docker-compose run-commando. Bijvoorbeeld, misschien wil je een Bash-terminal starten binnenin je bookstack-container. Om dat te doen, zou je het onderstaande commando uitvoeren.

docker-compose run web bash

Conclusie

Op dit moment zou je voldoende informatie moeten hebben om de meeste Docker Compose-tutorials op het web te volgen. Deze kennis kan aanzienlijk bijdragen aan je vermogen om de wereld van Docker in te gaan en web-apps te bouwen met Infrastructure as Code.

Source:
https://adamtheautomator.com/docker-compose-tutorial/