↓ Naar de hoofdinhoud gaan
Cursus DevOps

Voorbeelden

·1847 woorden·9 mins
Inhoudsopgave

Docker voorbeelden: installatie, Dockerfile, compose.yaml, volumes, netwerken
#

Hello World Image ★☆☆
#

Uitleg:

Dit is het meest eenvoudige Docker-voorbeeld. Het downloadt en start de hello-world-image van Docker Hub. Deze image toont simpelweg de melding “Hello from Docker!” en stopt vervolgens. Het laat het basisproces zien van het downloaden en uitvoeren van een Docker-image.

Nginx-webserver ★☆☆
# 

docker run -d -p 80:80 nginx

Uitleg:

Dit voorbeeld downloadt en start de officiële Nginx-webserver-image.

  • -d: Start de container in ‘detached’-modus (op de achtergrond).
  • -p 80:80: Koppelt poort 80 op de hostmachine aan poort 80 in de container, waardoor de webserver toegankelijk is via de browser van de host.

Aangepaste image met Dockerfile: Eenvoudige Node.js-app ★★☆
#

Dockerfile:

FROM node:14
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 3000
CMD ["npm", "start"]

Bouwen en uitvoeren:

docker build -t my-node-app .
docker run -d -p 3000:3000 my-node-app

Uitleg: Dit voorbeeld laat zien hoe je een aangepaste Docker-image bouwt met behulp van een Dockerfile voor een eenvoudige Node.js-applicatie.

  • Dockerfile:
  • FROM node:14: Gebruikt de officiële Node.js 14-image als basis.
  • WORKDIR /app: Stelt de werkmap in de container in op /app.
  • COPY package*.json ./: Kopieert package.json en package-lock.json (indien aanwezig) naar de container.
  • RUN npm install: Installeert de Node.js-dependencies.
  • COPY . .: Kopieert de rest van de applicatiecode naar de container. - EXPOSE 3000: Geeft aan dat de container zal luisteren op poort 3000.
  • CMD ["npm", "start"]: Definieert het commando dat wordt uitgevoerd wanneer de container start (start de Node.js-app).
  • Build: docker build -t my-node-app . bouwt de image en voorziet deze van de tag my-node-app.
  • Run: docker run -d -p 3000:3000 my-node-app start de container in ‘detached’-modus en koppelt poort 3000 op de host aan poort 3000 in de container.

Docker Compose: Web-app met database ★★☆
#

docker-compose.yaml:

version: "3.8"
services:
web:
image: nginx:latest
ports:
- "80:80"
volumes:
- ./html:/usr/share/nginx/html
- ./nginx.conf:/etc/nginx/conf.d/default.conf
depends_on:
- db
db:
image: mysql:5.7
environment:
MYSQL_ROOT_PASSWORD: example
MYSQL_DATABASE: mydb
volumes:
- db_data:/var/lib/mysql
volumes:
db_data:

nginx.conf:

server {
listen 80; 
server_name localhost; 
root /usr/share/nginx/html; 
index index.html; 

location / {
try_files $uri $uri/ =404; 
}

location /phpmyadmin {
proxy_pass http://db:80; 
proxy_set_header Host $host; 
proxy_set_header X-Real-IP $remote_addr; 
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; 
}
}

Uitvoeren:

docker-compose up -d

Uitleg:

Dit voorbeeld laat zien hoe je Docker Compose gebruikt om een ​​applicatie met meerdere containers te definiëren en uit te voeren, bestaande uit een webserver (Nginx) en een database (MySQL).

  • docker-compose.yaml:
  • version: "3.8": Specificeert de versie van het Docker Compose-bestandsformaat.
  • services:: Definieert de services (containers) in de applicatie.
  • web:: De webserverservice.
  • image: nginx:latest: Gebruikt de officiële Nginx-image.
  • ports: - "80:80": Koppelt poort 80 op de host aan poort 80 in de container.
  • volumes::
  • Koppelt de map ./html op de host aan /usr/share/nginx/html in de container, zodat je statische bestanden vanaf je lokale machine kunt serveren.
  • Koppelt het bestand ./nginx.conf aan /etc/nginx/conf.d/default.conf om Nginx te configureren.
  • depends_on: - db: Zorgt ervoor dat de db-service start vóór de web-service.
  • db:: De databaseservice.
  • image: mysql:5.7: Gebruikt de officiële MySQL 5.7-image.
  • environment:: Stelt omgevingsvariabelen in voor de MySQL-container (root-wachtwoord en databasenaam).
  • volumes: - db_data:/var/lib/mysql: Koppelt het benoemde volume db_data aan /var/lib/mysql om de databasegegevens te behouden (persistentie).
  • volumes: - db_data:: Definieert een benoemd volume genaamd db_data.
  • Uitvoeren: docker-compose up -d start de applicatie in ‘detached’-modus (op de achtergrond). ### #Named volume voor datapersistentie ★★☆

Dockerfile:

FROM ubuntu:latest
RUN apt-get update && apt-get install -y apache2
VOLUME /var/www/html
CMD ["apache2ctl", "-D", "FOREGROUND"]

Bouwen en uitvoeren:

docker build -t my-apache-app .
docker run -d -p 80:80 --name my-apache-container -v my-data:/var/www/html my-apache-app

Toelichting:

Dit voorbeeld laat zien hoe een ’named volume’ (benoemd volume) wordt gebruikt om gegevens te behouden in een Docker-container die een Apache-webserver draait.

  • Dockerfile:
  • VOLUME /var/www/html: Declareert /var/www/html (waar Apache websitebestanden opslaat) als een volume.
  • Uitvoeren:
  • -v my-data:/var/www/html: Koppelt de named volume my-data aan /var/www/html in de container. Wijzigingen aan bestanden in /var/www/html blijven behouden in de my-data-volume, zelfs als de container wordt gestopt of verwijderd.

Bind Mount voor ontwikkeling ★★☆
# 

docker run -d -p 80:80 -v $(pwd):/usr/share/nginx/html nginx

Uitleg:

Dit voorbeeld gebruikt een bind mount om de huidige werkmap ($(pwd)) op de hostmachine te koppelen aan /usr/share/nginx/html in de Nginx-container. Dit is handig voor ontwikkeling, omdat wijzigingen die je aanbrengt in bestanden in je lokale map direct zichtbaar zijn in de container.

Door de gebruiker gedefinieerd netwerk voor communicatie tussen containers ★★★
#

docker-compose.yaml:

version: "3.8"
services:
web:
image: nginx:latest
ports:
- "80:80"
networks:
- my-network
app:
image: my-node-app
networks:
- my-network
networks:
my-network:

Uitleg:

Dit voorbeeld laat zien hoe je een door de gebruiker gedefinieerd netwerk aanmaakt en daar twee services (containers) aan koppelt.

  • docker-compose.yaml:
  • networks:: Definieert een netwerk met de naam my-network.
  • services::
  • Zowel de web- als de app-service zijn gekoppeld aan het my-network-netwerk.
  • Containers die met hetzelfde door de gebruiker gedefinieerde netwerk zijn verbonden, kunnen met elkaar communiceren via hun servicenamen als hostnames. De app-container kan bijvoorbeeld de web-container bereiken via de hostname web. ### Multi-stage build voor een geoptimaliseerde image ★★★

Dockerfile:

# Fase 1: De applicatie bouwen
FROM node:14 AS build
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build
# Fase 2: Een compacte productie-image maken
FROM nginx:alpine
COPY --from=build /app/dist /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Toelichting:

Dit voorbeeld laat een multi-stage build zien om een ​​kleinere, meer geoptimaliseerde productie-image voor een Node.js-applicatie te maken.

  • Fase 1: Bouwt de applicatie in een Node.js-omgeving.
  • Fase 2: Kopieert alleen de gebouwde bestanden (uit /app/dist) naar een compacte Nginx Alpine-image, waarbij de onnodige build-tools en dependencies uit de eerste fase worden weggelaten.

Docker Compose met omgevingsvariabelen ★★☆
#

docker-compose.yaml:

version: "3.8"
services:
web:
image: my-node-app
ports:
- "80:3000"
environment:
NODE_ENV: production
API_KEY: ${API_KEY}

Toelichting:

Dit voorbeeld laat zien hoe je omgevingsvariabelen gebruikt in een Docker Compose-bestand.

  • environment:: Definieert omgevingsvariabelen voor de web-service.
  • NODE_ENV: production: Zet de omgevingsvariabele NODE_ENV op production.
  • API_KEY: ${API_KEY}: Leest de waarde van API_KEY uit een omgevingsvariabele op de hostmachine. Zorg ervoor dat je de omgevingsvariabele API_KEY op je host instelt voordat je docker-compose up uitvoert. ### #Dockerfile met Healthcheck ★★☆

Dockerfile:

FROM httpd:2.4
COPY ./public-html/ /usr/local/apache2/htdocs/
HEALTHCHECK --interval=5s --timeout=3s \
CMD curl -f http://localhost/ || exit 1

Uitleg:

Dit voorbeeld laat zien hoe je een healthcheck aan een Dockerfile toevoegt.

  • HEALTHCHECK: Definieert een healthcheck-commando dat door Docker wordt uitgevoerd om te controleren of de container gezond (healthy) is.
  • --interval=5s: Geeft aan dat de healthcheck elke 5 seconden moet worden uitgevoerd.
  • --timeout=3s: Geeft aan dat de healthcheck na 3 seconden een time-out moet geven.
  • CMD curl -f http://localhost/ || exit 1: Het healthcheck-commando zelf. Het gebruikt curl om te controleren of de webserver reageert op poort 80. Als het verzoek mislukt, eindigt het commando met een code die niet nul is, wat aangeeft dat de container ongezond (unhealthy) is.

Docker Compose met meerdere netwerken ★★★
#

docker-compose.yaml:

version: "3.8"
services:
frontend:
image: my-frontend-app
networks:
- frontend-network
- backend-network
backend:
image: my-backend-app
networks:
- backend-network
database:
image: mysql:5.7
networks:
- backend-network
networks:
frontend-network:
backend-network:

Uitleg:

Dit voorbeeld laat zien hoe je meerdere netwerken definieert en gebruikt in een Docker Compose-bestand.

  • networks:: Definieert twee netwerken: frontend-network en backend-network. - services::
  • frontend: Is verbonden met zowel frontend-network als backend-network, waardoor communicatie met zowel de backend als de buitenwereld mogelijk is.
  • backend: Is verbonden met backend-network, waardoor communicatie met de database mogelijk is.
  • database: Is verbonden met backend-network, waardoor communicatie met de backend mogelijk is.

Docker Compose met build-argumenten ★★☆
#

docker-compose.yaml:

version: "3.8"
services:

Docker Compose met build-argumenten ★★☆
#

docker-compose.yaml:

version: "3.8"
services:
  my-app:
    build:
      context: .
      args:
        VERSION: 1.0

Dockerfile:

FROM alpine:latest
ARG VERSION
RUN echo "Building version: $VERSION"

Uitleg:

Dit voorbeeld laat zien hoe je build-argumenten gebruikt in een Docker Compose-bestand.

  • build::
  • args:: Definieert een build-argument genaamd VERSION.
  • Het VERSION-argument wordt vervolgens in de Dockerfile gebruikt om het build-proces aan te passen.

Dockerfile met Entrypoint-script ★★★
#

Dockerfile:

FROM ubuntu:latest
COPY entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh
ENTRYPOINT ["/entrypoint.sh"]
CMD ["my-app"]

entrypoint.sh:

#!/bin/bash
echo "Starting my-app..."
exec "$@"

Uitleg:

Dit voorbeeld laat zien hoe je een entrypoint-script gebruikt in een Dockerfile.

  • ENTRYPOINT ["/entrypoint.sh"]: Geeft aan dat /entrypoint.sh moet worden uitgevoerd als het entrypoint voor de container.
  • CMD ["my-app"]: Specificeert het standaardcommando dat door het entrypoint-script moet worden uitgevoerd.

Het entrypoint-script kan worden gebruikt om voorbereidende taken uit te voeren voordat de hoofdapplicatie start. In dit voorbeeld wordt simpelweg een bericht getoond, waarna het commando uit CMD wordt uitgevoerd.

Docker Compose met schalen ★★☆
#

docker-compose.yaml:

version: "3.8"
services:
web:
image: nginx:latest
ports:
- "80:80"
deploy:
replicas: 3

Uitleg:

Dit voorbeeld laat zien hoe je een service schaalt in een Docker Compose-bestand.

  • deploy::
  • replicas: 3: Geeft aan dat er 3 instanties van de web-service moeten draaien. ### #Dockerfile met ONBUILD-instructie ★★★

Dockerfile (basis-image):

FROM node:14

WORKDIR /app

ONBUILD COPY package*.json ./
ONBUILD RUN npm install
ONBUILD COPY . .

Dockerfile (applicatie-image):

FROM my-base-image
CMD ["npm", "start"]

Uitleg:

Dit voorbeeld laat zien hoe de ONBUILD-instructie in een Dockerfile wordt gebruikt.

  • ONBUILD: Specificeert instructies die worden uitgevoerd wanneer de image als basis-image voor een andere image wordt gebruikt.
  • In dit voorbeeld definieert de image my-base-image ONBUILD-instructies om bestanden te kopiëren en afhankelijkheden te installeren. Wanneer de applicatie-image wordt gebouwd, worden deze instructies automatisch uitgevoerd.

Docker Compose met profielen ★★★
#

docker-compose.yaml:

version: "3.8"
services:
web:
image: my-web-app
profiles: ["frontend"]
api:
image: my-api-app
profiles: ["backend"]
db:
image: mysql:5.7
profiles: ["backend"]

profiles:
frontend:
backend:

Uitleg:

Dit voorbeeld laat zien hoe profielen in een Docker Compose-bestand worden gebruikt.

  • profiles: Hiermee kun je groepen services definiëren die gezamenlijk kunnen worden in- of uitgeschakeld.
  • In dit voorbeeld maakt de web-service deel uit van het frontend-profiel, terwijl de api- en db-services deel uitmaken van het backend-profiel.
  • Om alleen de frontend-services te starten, voer je uit: docker-compose up -d --profile frontend.
  • Om alleen de backend-services te starten, voer je uit: docker-compose up -d --profile backend.
  • Om alle services te starten, voer je uit: docker-compose up -d. ### #Dockerfile met .dockerignore ★★☆

.dockerignore:

node_modules
.git

Dockerfile:

FROM node:14
WORKDIR /app
COPY . .
RUN npm install
CMD ["npm", "start"]

Uitleg:

Dit voorbeeld laat zien hoe je een .dockerignore-bestand gebruikt om bestanden en mappen uit te sluiten van het kopiëren naar de Docker-image.

  • Het .dockerignore-bestand bevat patronen die overeenkomen met de bestanden en mappen die moeten worden uitgesloten. In dit voorbeeld worden de mappen node_modules en .git uitgesloten.

#Docker Compose met override-bestand ★★★
#

docker-compose.yaml:

version: "3.8"
services:
web:
image: my-web-app
ports:
- "80:80"

docker-compose.override.yaml:

version: "3.8"
services:
web:
environment:
DEBUG: "true"

Uitleg:

Dit voorbeeld laat zien hoe je een override-bestand gebruikt om de configuratie van services in een Docker Compose-bestand aan te passen.

  • Het bestand docker-compose.override.yaml bevat configuratie die de configuratie in het bestand docker-compose.yaml overschrijft.
  • In dit voorbeeld wordt de omgevingsvariabele DEBUG ingesteld voor de web-service in het override-bestand. ### #Docker Compose met depends_on en healthcheck ★★★

docker-compose.yaml:

version: "3.8"
services:
db:
image: mysql:5.7
healthcheck:
test: ["CMD", "mysqladmin" ,"ping", "-h", "localhost"]
interval: 10s
timeout: 5s
retries: 5
web:
image: my-web-app
ports:
- "80:80"
depends_on:
db:
condition: service_healthy

Toelichting:

Dit voorbeeld combineert depends_on en healthcheck in een Docker Compose-bestand om services in een specifieke volgorde te starten, op basis van de gezondheidsstatus van hun afhankelijkheden.

  • db-service:
  • Heeft een healthcheck