Docker Beginnershandleiding: Snel aan de slag met het containeriseren van je applicatie

# Docker Beginnershandleiding: Snel aan de slag met het containeriseren van je applicatie

Docker is een onmisbaar onderdeel geworden van moderne softwareontwikkeling en -implementatie. Ondanks de overweldigende hoeveelheid discussie rond Kubernetes, blijft Docker voor veel bedrijven de tool bij uitstek voor het bouwen, testen en implementeren van applicaties. Dit artikel neemt je mee door een snelle introductie tot Docker, legt de kernconcepten uit en biedt een praktisch voorbeeld om je te helpen aan de slag te gaan met het containeriseren van je applicatie.

## Docker Kernconcepten

Voordat je begint met de praktijk, is het essentieel om enkele kernconcepten van Docker te begrijpen:

*   **Image (Afbeelding):** Een image is een alleen-lezen sjabloon die alles bevat wat nodig is om een applicatie uit te voeren: code, runtime-omgeving, systeemtools, bibliotheken en afhankelijkheden. Vergelijkbaar met een virtuele machine image, maar dan lichter.

*   **Container:** Een container is een actieve instantie die is gemaakt van een image. Het is een runtime-instantie van een image, die de applicatie en al haar afhankelijkheden bevat. Containers zijn van elkaar geïsoleerd en hebben hun eigen bestandssysteem, processen en netwerkruimte.

*   **Docker Hub:** Docker Hub is een openbare image repository waar je vooraf gebouwde images kunt downloaden en je eigen images kunt uploaden. Vergelijkbaar met GitHub, maar dan specifiek voor Docker images.

*   **Dockerfile:** Een Dockerfile is een tekstbestand dat alle instructies bevat voor het bouwen van een Docker image. Door een Dockerfile te schrijven, kun je het proces van het maken van een image automatiseren.

*   **Docker Compose:** Docker Compose is een tool voor het definiëren en uitvoeren van Docker-applicaties met meerdere containers. Hiermee kun je de services van een applicatie configureren met behulp van een YAML-bestand en vervolgens alle services starten of stoppen met één commando.

## Docker Installatie

Eerst moet je Docker installeren. Docker biedt installatiepakketten voor verschillende besturingssystemen. Ga naar de [Docker officiële website](https://www.docker.com/get-started/) en volg de bijbehorende instructies voor de installatie.

Nadat de installatie is voltooid, kun je controleren of Docker correct is geïnstalleerd door het commando `docker --version` uit te voeren.

## Een eenvoudige Python-applicatie containeriseren

We gaan een eenvoudige Python-applicatie maken en deze containeriseren met behulp van Docker.

### 1. Maak een Python-applicatie

Maak een bestand met de naam `app.py` met de volgende code:

```python
from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello, Docker!"

if __name__ == "__main__":
    app.run(debug=True, host='0.0.0.0')

Deze eenvoudige Flask-applicatie retourneert "Hello, Docker!" op de root-path /.

2. Maak een requirements.txt-bestand

De applicatie is afhankelijk van de Flask-bibliotheek, dus we moeten een requirements.txt-bestand maken om deze afhankelijkheden te declareren.

Flask

3. Maak een Dockerfile

Maak een bestand met de naam Dockerfile en voeg de volgende inhoud toe:

# Gebruik de officiële Python-image als basisimage
FROM python:3.9-slim-buster

# Stel de werkdirectory in
WORKDIR /app

# Kopieer het requirements.txt-bestand naar de werkdirectory
COPY requirements.txt .

# Installeer de afhankelijkheden
RUN pip install --no-cache-dir -r requirements.txt
```# Kopieer de applicatiecode naar de werkdirectory
COPY app.py .

# Stel poort 5000 bloot
EXPOSE 5000

# Definieer de startopdracht
CMD ["python", "app.py"]

Dockerfile Uitleg:

• FROM python:3.9-slim-buster: Specificeert de basisimage als een slanke versie van Python 3.9.
• WORKDIR /app: Stelt de werkdirectory binnen de container in op /app.
• COPY requirements.txt .: Kopieert het requirements.txt-bestand uit de huidige directory naar de /app-directory van de container.
• RUN pip install --no-cache-dir -r requirements.txt: Voert de pip-opdracht uit in de container om de afhankelijkheden te installeren die zijn gespecificeerd in het requirements.txt-bestand. De --no-cache-dir-parameter kan de grootte van de image verkleinen.
• COPY app.py .: Kopieert het app.py-bestand uit de huidige directory naar de /app-directory van de container.
• EXPOSE 5000: Declareert dat de container luistert op poort 5000.
• CMD ["python", "app.py"]: Definieert de opdracht die moet worden uitgevoerd wanneer de container wordt gestart.

4. Bouw de Docker-image

Voer de volgende opdracht uit in de directory die het Dockerfile bevat om de Docker-image te bouwen:

docker build -t my-python-app .

• docker build: De opdracht om de image te bouwen.
• -t my-python-app: Geeft de image een naam (my-python-app).
• .: Specificeert de directory waar het Dockerfile zich bevindt (de huidige directory).

Het bouwproces kan enige tijd duren, afhankelijk van de netwerksnelheid en de grootte van de afhankelijkheden.

5. Voer de Docker-container uit

Gebruik de volgende opdracht om de Docker-container uit te voeren:

docker run -d -p 5000:5000 my-python-app

• docker run: De opdracht om de container uit te voeren.
• -d: Voert de container uit in de detached modus (op de achtergrond).
• -p 5000:5000: Wijst poort 5000 van de hostmachine toe aan poort 5000 van de container.
• my-python-app: Specificeert de naam van de image die moet worden gebruikt.

6. Verifieer de applicatie

Bezoek http://localhost:5000 in een browser, je zou "Hello, Docker!" moeten zien.

7. Stop en verwijder de container

Gebruik de volgende opdracht om de container te stoppen:

docker stop 

`` kan worden bekeken met de opdracht docker ps.

Gebruik de volgende opdracht om de container te verwijderen:

docker rm 

Aan de slag met Docker Compose

Als je applicatie uit meerdere services bestaat, kun je Docker Compose gebruiken om ze te beheren.

1. Maak een docker-compose.yml-bestand

Maak een bestand met de naam docker-compose.yml en voeg de volgende inhoud toe:

version: "3.9"
services:
  web:
    image: my-python-app
    ports:
      - "5000:5000"

docker-compose.yml Uitleg:* version: "3.9": Specificeert de versie van het Docker Compose-bestand.

• services: Definieert de services van de applicatie.
• web: Definieert een service met de naam "web".
• image: my-python-app: Specificeert de image die de service gebruikt.
• ports: Definieert poortmappings.

2. Start de applicatie

Voer de volgende opdracht uit in de map die het docker-compose.yml-bestand bevat om de applicatie te starten:

docker-compose up -d

• docker-compose up: De opdracht om de applicatie te starten.
• -d: Voert de container uit in de detached mode (op de achtergrond).

3. Stop de applicatie

Gebruik de volgende opdracht om de applicatie te stoppen:

docker-compose down

Docker Beste Praktijken voor Beveiliging

Zoals uit de discussie blijkt, is de beveiliging van Docker-images een belangrijk probleem. Hier zijn enkele Docker beste praktijken voor beveiliging:

• Gebruik officiële images: Gebruik zoveel mogelijk de officieel geleverde images, deze images worden meestal gescand op beveiliging en onderhouden.
• Scan images op kwetsbaarheden: Gebruik tools zoals Trivy om images te scannen op bekende kwetsbaarheden en update de images tijdig.
• Gebruik het principe van minimale rechten: Vermijd het uitvoeren van containers als root-gebruiker.
• Beperk containerresources: Gebruik cgroups om het CPU- en geheugengebruik van de container te beperken.
• Update images regelmatig: Houd images up-to-date om beveiligingslekken te verhelpen.
• Gebruik tools voor beveiligingsscans: Tools zoals Snyk, Clair, enz. kunnen worden geïntegreerd in uw CI/CD-proces om automatisch images te scannen op kwetsbaarheden.

ConclusieDit artikel biedt een snelle startgids voor Docker, die de kernconcepten, installatiestappen en een eenvoudig voorbeeld van containerisatie van een Python-applicatie behandelt. Door deze basisprincipes te leren, kunt u Docker gaan gebruiken om uw applicaties te bouwen, testen en implementeren. Onthoud dat veiligheid van cruciaal belang is, besteed altijd aandacht aan de veiligheid van Docker-images en neem passende maatregelen om uw applicaties te beschermen. Hoewel Kubernetes krachtig is in grootschalige containerorkestratie, is Docker in veel scenario's nog steeds een eenvoudige en effectieve oplossing. Door Docker onder de knie te krijgen, bent u beter in staat om de uitdagingen van moderne softwareontwikkeling en -implementatie aan te gaan.