6.1 Authentifizierung und Autorisierung von Benutzern
An dieser Stelle schauen wir uns an, wie wir die Sicherheit unserer Multi-Container-Anwendung gewährleisten und den Zugriff verwalten können. Dies umfasst die Authentifizierung von Benutzern, Datenverschlüsselung, den Schutz von APIs und die Konfiguration sicherer Verbindungen zwischen den Diensten.
Ziel: sicherstellen, dass nur registrierte und authentifizierte Benutzer mit der Anwendung interagieren und Operationen ausführen können.
Implementierung von JWT (JSON Web Token) für die Authentifizierung
Schritt 1. Installation der benötigten Bibliotheken:
pip install Flask-JWT-Extended
Schritt 2. JWT-Konfiguration in der Flask-Anwendung:
Füge die folgenden Änderungen in Datei backend/app/__init__.py hinzu:
from flask_jwt_extended import JWTManager
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://taskuser:taskpassword@database:5432/taskdb'
app.config['JWT_SECRET_KEY'] = 'Ihr_jwt_secret_key' # Ersetzen Sie dies durch Ihren geheimen Schlüssel
db = SQLAlchemy(app)
jwt = JWTManager(app)
from app import routes
Schritt 3. Erstellen von Routen für Registrierung und Authentifizierung:
Füge die folgenden Routen in die Datei backend/app/routes.py hinzu:
from flask_jwt_extended import create_access_token, jwt_required, get_jwt_identity
from werkzeug.security import generate_password_hash, check_password_hash
from app.models import User, Task
@app.route('/register', methods=['POST'])
def register():
data = request.get_json()
hashed_password = generate_password_hash(data['password'], method='sha256')
new_user = User(username=data['username'], password=hashed_password)
db.session.add(new_user)
db.session.commit()
return jsonify({'message': 'Benutzer erfolgreich registriert'}), 201
@app.route('/login', methods=['POST'])
def login():
data = request.get_json()
user = User.query.filter_by(username=data['username']).first()
if not user or not check_password_hash(user.password, data['password']):
return jsonify({'message': 'Ungültige Anmeldedaten'}), 401
access_token = create_access_token(identity=user.id)
return jsonify({'access_token': access_token}), 200
@app.route('/tasks', methods=['GET'])
@jwt_required()
def get_tasks():
current_user_id = get_jwt_identity()
tasks = Task.query.filter_by(owner_id=current_user_id).all()
return jsonify([task.to_dict() for task in tasks])
Schritt 4. Aktualisierung des User-Modells zur Speicherung von Passwörtern:
Aktualisiere die Datei backend/app/models.py:
from app import db
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
password = db.Column(db.String(120), nullable=False)
tasks = db.relationship('Task', backref='owner', lazy=True)
6.2 Datenverschlüsselung
Ziel: Schutz der Daten bei der Übertragung zwischen Client und Server gewährleisten.
Verwendung von HTTPS
Schritt 1. Konfiguration von Nginx als Reverse-Proxy mit HTTPS-Unterstützung:
Erstelle die Datei nginx.conf im Stammverzeichnis des Projekts:
server {
listen 80;
server_name your_domain.com;
location / {
proxy_pass http://frontend:3000;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
location /api {
proxy_pass http://backend:5000;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
}
Schritt 2. Erstellen eines Dockerfile für Nginx:
Erstelle die Datei Dockerfile im Verzeichnis nginx:
FROM nginx:latest
COPY nginx.conf /etc/nginx/nginx.conf
Schritt 3. Hinzufügen von Nginx zur compose.yaml:
Aktualisiere die Datei compose.yaml, indem du den Service für Nginx hinzufügst:
version: '3'
services:
frontend:
build: ./frontend
ports:
- "3000:3000"
networks:
- task-network
backend:
build: ./backend
ports:
- "5000:5000"
depends_on:
- database
networks:
- task-network
environment:
- DATABASE_URL=postgresql://taskuser:taskpassword@database:5432/taskdb
database:
image: postgres:13
environment:
- POSTGRES_DB=taskdb
- POSTGRES_USER=taskuser
- POSTGRES_PASSWORD=taskpassword
networks:
- task-network
volumes:
- db-data:/var/lib/postgresql/data
nginx:
build: ./nginx
ports:
- "80:80"
depends_on:
- frontend
- backend
networks:
- task-network
networks:
task-network:
driver: bridge
volumes:
db-data:
6.3 SSL-Zertifikat mit Let's Encrypt erhalten
Schritt 1: Certbot installieren:
Folge den Anweisungen auf der offiziellen Certbot-Website, um Certbot zu installieren.
Schritt 2: Zertifikat erhalten:
sudo certbot certonly --standalone -d your_domain.com
Schritt 3: Nginx für SSL einrichten:
Aktualisiere nginx.conf, um SSL zu verwenden:
server {
listen 80;
server_name your_domain.com;
return 301 https://$host$request_uri;
}
server {
listen 443 ssl;
server_name your_domain.com;
ssl_certificate /etc/letsencrypt/live/your_domain.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/your_domain.com/privkey.pem;
location / {
proxy_pass http://frontend:3000;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
location /api {
proxy_pass http://backend:5000;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
}
Schritt 4: Dockerfile für Nginx aktualisieren, um Zertifikate zu kopieren:
FROM nginx:latest
COPY nginx.conf /etc/nginx/nginx.conf
COPY /etc/letsencrypt /etc/letsencrypt
6.4 Schutz von APIs
Ziel: Zugriff auf APIs einschränken und unautorisierte Anfragen verhindern.
Verwendung von JWT für den Schutz von Routen
Wir haben bereits Routen für Tasks geschützt, indem wir den Decorator @jwt_required() verwendet haben. Stelle sicher, dass alle sensiblen Routen mit diesem Decorator geschützt sind:
from flask_jwt_extended import jwt_required, get_jwt_identity
@app.route('/tasks', methods=['GET'])
@jwt_required()
def get_tasks():
current_user_id = get_jwt_identity()
tasks = Task.query.filter_by(owner_id=current_user_id).all()
return jsonify([task.to_dict() for task in tasks])
Zugriff auf die Datenbank einschränken
Ziel: Unautorisierte Zugriffe auf die Datenbank verhindern.
Einrichten von Rollen und Berechtigungen
Schritt 1. Erstellung eines Nutzers mit eingeschränkten Berechtigungen:
CREATE USER limited_user WITH PASSWORD 'limited_password';
GRANT CONNECT ON DATABASE taskdb TO limited_user;
GRANT USAGE ON SCHEMA public TO limited_user;
GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO limited_user;
Schritt 2. Aktualisieren der Umgebungsvariable DATABASE_URL:
Aktualisiere die Umgebungsvariable DATABASE_URL in der Datei compose.yaml:
environment:
- DATABASE_URL=postgresql://limited_user:limited_password@database:5432/taskdb
GO TO FULL VERSION