Natuurlijk! Hieronder vind je een stapsgewijze uitleg om je Flask-toepassing te containeriseren met Docker, rekening houdend met best practices voor ontwikkeling en productie. 1. Structuur van je project Je hebt: - /mijnapp/app.py - /mijnapp/templates/ Zorg dat je project er ongeveer zo uitziet: ``` mijnapp/ │ ├── app.py └── templates/ ``` 2. Maak een Dockerfile Plaats deze in de map /mijnapp/. Bijvoorbeeld: /mijnapp/Dockerfile Hier is een voorbeeld van een goede Dockerfile: ```dockerfile # Stap 1: Gebruik een lichte basis image met Python FROM python:3.11-slim # Stap 2: Stel de werkdirectory in WORKDIR /app # Stap 3: Kopieer requirements-bestand als je die hebt, anders installeer je direct # Als je geen requirements-bestand hebt, kun je dependencies direct installeren # Stap 4: Installeer afhankelijkheden # Voor ontwikkelomgeving voeg --upgrade toe, voor productie minimaliseer afhankelijkheden # Hier voor eenvoud, je kunt later een requirements.txt maken RUN pip install --no-cache-dir Flask # Stap 5: Kopieer de applicatiebestanden naar de container COPY app.py /app/ COPY templates/ /app/templates/ # Stap 6: Exposeer de poort waarop je Flask-app draait EXPOSE 5000 # Stap 7: Definieer het opstartcommando CMD ["flask", "run", "--host=0.0.0.0"] ``` **Tip:** Als je dependencies complexer worden, maak dan een requirements.txt en kopieer dat in de Dockerfile. Bijvoorbeeld: - Maak requirements.txt met: ``` Flask ``` - Pas Dockerfile aan: ```dockerfile COPY requirements.txt /app/ RUN pip install --no-cache-dir -r requirements.txt ``` 3. Maak een requirements.txt (optioneel, maar aanbevolen) In /mijnapp/ maak een bestand requirements.txt met je dependencies: ``` Flask ``` 4. Gebruik environment variables voor Flask Voeg in je app.py toe: ```python import os from flask import Flask app = Flask(__name__) @app.route("/") def index(): return "Hallo, wereld!" if __name__ == "__main__": app.run(host='0.0.0.0', port=5000) ``` Of stel de FLASK_APP variabele in bij het opstarten. 5. Bouw de Docker-image Open een terminal in /mijnapp/ en voer uit: ```bash docker build -t mijnflaskapp . ``` 6. Run de container Voor ontwikkeling: ```bash docker run -p 5000:5000 -v $(pwd):/app mijnflaskapp ``` De `-v` optie mount je code voor live development. Voor productie: ```bash docker run -d -p 80:5000 mijnflaskapp ``` 7. Beste praktijken en optimalisaties - Gebruik voor productie een minimalistische base image zoals `python:3.11-slim`. - Maak een aparte requirements.txt voor dependencies. - Gebruik `.dockerignore` om onnodige bestanden uit te sluiten (bijvoorbeeld `.git`, `__pycache__`). - Zet environment variables voor configuratie. - Overweeg een WSGI-server zoals Gunicorn voor productie (`pip install gunicorn`) en pas de CMD aan: ```dockerfile CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:5000", "app:app"] ``` 8. Samenvatting - Maak een Dockerfile die dependencies installeert en je app kopieert. - Bouw je image met `docker build`. - Run je container met `docker run`. - Pas voor productie je setup aan voor stabiliteit en performance. Als je verdere hulp nodig hebt of je setup wilt verfijnen, laat het gerust weten!

Zeker! Ik help je stap voor stap met het containeriseren van je Flask-applicatie met Docker. Hier is een complete handleiding: ## 1. Basis Dockerfile maken Maak een `Dockerfile` in je hoofdmap (`/mijnapp/`): ```dockerfile # Gebruik een officiële Python runtime als basisimage FROM python:3.11-slim # Stel werkdirectory in WORKDIR /app # Kopieer eerst requirements.txt voor betere caching COPY requirements.txt . # Installeer dependencies RUN pip install --no-cache-dir -r requirements.txt # Kopieer de rest van de applicatie COPY . . # Poort vrijgeven EXPOSE 5000 # Omgevingsvariabele voor Flask ENV FLASK_APP=app.py ENV FLASK_ENV=production # Startcommando CMD ["flask", "run", "--host=0.0.0.0"] ``` ## 2. Requirements.txt aanmaken Maak een `requirements.txt` in je hoofdmap: ```txt Flask==2.3.3 Werkzeug==2.3.7 ``` Je kunt je specifieke dependencies hier toevoegen. ## 3. .dockerignore bestand Maak een `.dockerignore` om onnodige bestanden buiten de container te houden: ```dockerignore __pycache__ *.pyc *.pyo *.pyd .Python env pip-log.txt pip-delete-this-directory.txt .tox .coverage .coverage.* .cache nosetests.xml coverage.xml *.cover *.log .git .mypy_cache .pytest_cache .history ``` ## 4. Docker Image bouwen ```bash # Bouw de image docker build -t mijn-flask-app . # Run de container docker run -p 5000:5000 mijn-flask-app ``` ## 5. Docker Compose voor ontwikkeling Maak een `docker-compose.yml` voor ontwikkelingsgemak: ```yaml version: '3.8' services: web: build: . ports: - "5000:5000" volumes: - .:/app environment: - FLASK_ENV=development - FLASK_DEBUG=1 command: flask run --host=0.0.0.0 --reload ``` ## 6. Geoptimaliseerde Dockerfile voor productie ```dockerfile # Build stage FROM python:3.11-slim as builder WORKDIR /app COPY requirements.txt . RUN pip install --user --no-cache-dir -r requirements.txt # Runtime stage FROM python:3.11-slim WORKDIR /app # Kopieer alleen geïnstalleerde packages van builder stage COPY --from=builder /root/.local /root/.local COPY . . # Zorg dat scripts in PATH staan ENV PATH=/root/.local/bin:$PATH ENV FLASK_APP=app.py ENV FLASK_ENV=production # Gebruiker maken voor betere security RUN useradd --create-home --shell /bin/bash app USER app EXPOSE 5000 CMD ["flask", "run", "--host=0.0.0.0"] ``` ## 7. Multi-stage build met Gunicorn Voor productie met WSGI server: ```dockerfile # Build stage FROM python:3.11-slim as builder WORKDIR /app COPY requirements.txt . RUN pip install --user --no-cache-dir -r requirements.txt # Runtime stage FROM python:3.11-slim WORKDIR /app COPY --from=builder /root/.local /root/.local COPY . . ENV PATH=/root/.local/bin:$PATH # Installeer gunicorn RUN pip install --user gunicorn RUN useradd --create-home --shell /bin/bash app USER app EXPOSE 5000 CMD ["gunicorn", "--bind", "0.0.0.0:5000", "app:app"] ``` ## 8. Best practices voor optimalisatie ### Voor ontwikkeling: - Gebruik bind mounts voor live reload - Gebruik `--reload` flag bij Flask - Houd development dependencies gescheiden ### Voor productie: - Gebruik multi-stage builds - Minimal base images (python:slim) - `--no-cache-dir` met pip - Gebruik .dockerignore - Run als non-root user - Gebruik specifieke versietags ## 9. Uitgebreide requirements.txt voor productie ```txt Flask==2.3.3 Werkzeug==2.3.7 gunicorn==21.2.0 ``` ## 10. Gebruik in productie ```bash # Build met productie Dockerfile docker build -t mijn-flask-app:prod . # Run met environment variables docker run -d -p 5000:5000 \ -e FLASK_ENV=production \ --name flask-app \ mijn-flask-app:prod ``` ## Projectstructuur na implementatie: ``` /mijnapp/ ├── Dockerfile ├── docker-compose.yml ├── .dockerignore ├── requirements.txt ├── app.py └── templates/ └── ... je template bestanden ``` Met deze setup heb je een geoptimaliseerde Docker-configuratie die zowel voor ontwikkeling als productie geschikt is!