CodeGym /Kursy /Docker SELF /Bezpieczeństwo i zarządzanie dostępem

Bezpieczeństwo i zarządzanie dostępem

Docker SELF

Poziom 24 , Lekcja 0

Dostępny

6.1 Uwierzytelnianie i autoryzacja użytkowników

Na tym etapie przyjrzymy się, jak zapewnić bezpieczeństwo naszej aplikacji wielokontenerowej i zarządzać dostępem. Obejmuje to uwierzytelnianie użytkowników, szyfrowanie danych, ochronę API i konfigurację bezpiecznych połączeń między usługami.

Cel: upewnić się, że tylko zarejestrowani i uwierzytelnieni użytkownicy mogą korzystać z aplikacji i wykonywać operacje.

Implementacja JWT (JSON Web Token) do uwierzytelniania

Krok 1. Instalacja wymaganych bibliotek:

Terminal


pip install Flask-JWT-Extended

Krok 2. Konfiguracja JWT w aplikacji Flask:

Dodaj następujące zmiany do pliku backend/app/__init__.py:

Python


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'] = 'your_jwt_secret_key'  # Zamień na swój klucz tajny
db = SQLAlchemy(app)
jwt = JWTManager(app)
        
from app import routes

Krok 3. Tworzenie tras do rejestracji i autoryzacji:

Dodaj następujące trasy do pliku backend/app/routes.py:

Python


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': 'Użytkownik został zarejestrowany pomyślnie'}), 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': 'Nieprawidłowe dane uwierzytelniające'}), 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])

Krok 4. Aktualizacja modelu User do przechowywania haseł:

Zaktualizuj plik backend/app/models.py:

Python


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 Szyfrowanie danych

Cel: zapewnić ochronę danych podczas przesyłania między klientem a serwerem.

Używanie HTTPS

Krok 1. Konfiguracja Nginx jako reverse proxy z obsługą HTTPS:

Utwórz plik nginx.conf w katalogu głównym projektu:

Text


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;
    }
}

Krok 2. Tworzenie Dockerfile dla Nginx:

Utwórz plik Dockerfile w katalogu nginx:

dockerfile


FROM nginx:latest
COPY nginx.conf /etc/nginx/nginx.conf

Krok 3. Dodanie Nginx do compose.yaml:

Zaktualizuj plik compose.yaml, dodając usługę dla Nginx:

Yaml


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 Uzyskanie certyfikatu SSL za pomocą Let's Encrypt

Krok 1. Instalacja Certbot:

Postępuj zgodnie z instrukcjami na oficjalnej stronie Certbot, aby zainstalować Certbot.

Krok 2. Uzyskanie certyfikatu:

Terminal


sudo certbot certonly --standalone -d your_domain.com

Krok 3. Konfiguracja Nginx do użycia SSL:

Zaktualizuj nginx.conf, aby używać SSL:

Tekst


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;
    }
}

Krok 4. Aktualizacja Dockerfile dla Nginx, aby skopiować certyfikaty:

dockerfile


FROM nginx:latest
COPY nginx.conf /etc/nginx/nginx.conf
COPY /etc/letsencrypt /etc/letsencrypt

6.4 Ochrona API

Cel: ograniczenie dostępu do API i zapobieganie nieautoryzowanym żądaniom.

Używanie JWT do ochrony tras

Już dodaliśmy ochronę dla tras zadań, używając dekoratora @jwt_required(). Upewnij się, że wszystkie wrażliwe trasy są chronione tym dekoratorem:

Python


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])

Ograniczenie dostępu do bazy danych

Cel: zapobieganie nieautoryzowanemu dostępowi do bazy danych.

Konfigurowanie ról i przywilejów

Krok 1. Tworzenie użytkownika z ograniczonymi przywilejami:

SQL


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;

Krok 2. Aktualizacja zmiennej środowiskowej DATABASE_URL:

Zaktualizuj zmienną środowiskową DATABASE_URL w pliku compose.yaml:

Yaml


environment:
  - DATABASE_URL=postgresql://limited_user:limited_password@database:5432/taskdb

Poprzednia Poprzednia lekcja

Następny Następna lekcja

Komentarze

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION