Ubuntu 22.04에서 Redis를 사용하여 Python/MySQL 애플리케이션 세션 처리 속도 향상하는 방법

튜토리얼
MySQL Python Redis Ubuntu

소개

인증은 로그인 요청 중 사용자의 신원을 확인하는 과정입니다. 인증 과정에서 사용자는 사용자 이름과 비밀번호와 같은 자격 증명을 제출합니다. 그런 다음, 응용 프로그램은 해당 로그인 자격 증명을 저장된 데이터베이스 항목과 일치시킵니다. 일치하는 경우 응용 프로그램은 사용자에게 시스템에 대한 액세스 권한을 부여합니다.

MySQL 또는 PostgreSQL과 같은 관계형 데이터베이스에 로그인 자격 증명을 캐싱 메커니즘 없이 저장하는 것은 여전히 일반적이고 실용적인 방법입니다. 그러나 다음과 같은 제한 사항이 있습니다:

  • 데이터베이스 과부하. 응용 프로그램은 사용자가 로그인 요청을 제출할 때마다 데이터베이스 서버로 왕복하여 데이터베이스 테이블에서 사용자의 자격 증명을 확인해야 합니다. 데이터베이스는 여전히 다른 읽기/쓰기 요청을 처리할 수 있기 때문에 전체 프로세스는 데이터베이스를 과부하로 만들어 느려집니다.

  • 전통적인 디스크 기반 데이터베이스는 확장성 문제가 있습니다. 애플리케이션이 초당 수천 개의 요청을 받을 때, 디스크 기반 데이터베이스는 최적으로 작동하지 않습니다.

위의 문제를 해결하기 위해 Redis를 사용하여 사용자의 로그인 자격 증명을 캐시로 사용할 수 있습니다. 이렇게 하면 로그인 요청마다 백엔드 데이터베이스에 연락할 필요가 없습니다. Redis는 컴퓨터의 RAM을 사용하여 데이터를 키-값 쌍으로 저장하는 가장 인기있는 초고속 데이터 저장소 중 하나입니다. 이 가이드에서는 Ubuntu 22.04 서버에서 Python/MySQL 애플리케이션의 세션 처리 속도를 높이기 위해 Redis 데이터베이스를 사용할 것입니다.

전제 조건

이 튜토리얼을 시작하기 전에 다음을 설정해야 합니다:

단계 1 — Redis와 MySQL을 위한 Python 데이터베이스 드라이버 설치

이 애플리케이션은 사용자의 자격 증명(이름 및 비밀번호)을 MySQL 데이터베이스 서버에 영구적으로 저장합니다. 사용자가 애플리케이션에 로그인하면 Python 스크립트가 MySQL 데이터베이스를 쿼리하여 세부 정보를 저장된 값과 일치시킵니다. 그런 다음, Python 스크립트는 사용자의 로그인 자격 증명을 Redis 데이터베이스에 캐시하여 다른 미래 요청에 사용합니다. 이 논리를 완료하기 위해 Python 스크립트에는 MySQL 및 Redis 서버와 통신하기 위한 데이터베이스 드라이버(파이썬 모듈)가 필요합니다. 아래 단계를 따라 드라이버를 설치하세요:

  1. 패키지 정보 인덱스를 업데이트하고 다음 명령을 실행하여 python3-pip를 설치하세요. 이는 파이썬 표준 라이브러리에 포함되어 있지 않은 추가 모듈을 설치할 수 있는 파이썬 패키지 관리자입니다.
sudo apt install python3-pip
  1. Python용 MySQL 드라이버를 설치하세요:
pip install mysql-connector-python
  1. Python용 Redis 드라이버를 설치하세요:
pip install redis

MySQL 및 Redis와 통신하기 위해 필요한 드라이버를 설치한 후, 다음 단계로 진행하여 MySQL 데이터베이스를 초기화하세요.

2단계 – 샘플 MySQL 데이터베이스 설정

이 안내서에서는 하나의 MySQL 테이블이 필요합니다. 실제 환경에서는 다른 요청을 처리하는 수십 개의 테이블이 있을 수 있습니다. 다음 명령을 실행하여 데이터베이스를 설정하고 테이블을 생성하세요.

  1. MySQL 데이터베이스 서버에 root 사용자로 로그인하세요:

    sudo mysql -u root -p

  2. 요청 시 MySQL 서버의 root 비밀번호를 입력하고 ENTER를 눌러 진행하세요. 그런 다음 다음 명령을 실행하여 샘플 company 데이터베이스와 company_user 계정을 생성하세요. example-mysql-password를 강력한 암호로 대체하세요:

  1. CREATE DATABASE company;

  2. CREATE USER 'company_user'@'localhost' IDENTIFIED WITH mysql_native_password BY 'example-mysql-password';

  3. GRANT ALL PRIVILEGES ON company.* TO 'company_user'@'localhost';

  4. FLUSH PRIVILEGES;

  1. 이전 명령이 성공적으로 실행되었음을 확인하기 위해 다음 출력을 받으세요:

    출력
    Query OK, 1 row affected (0.01 sec)

  2. 새로운 company 데이터베이스로 전환하세요:

    1. USE company;

  3. 다음 출력을 확인하여 새 데이터베이스에 연결되었는지 확인하세요:

    출력
    Database changed

  4. 시스템 사용자

    테이블을 생성합니다. user_id 열은 각 사용자를 고유하게 식별하기 위한 PRIMARY KEY로 사용됩니다. username 및 password 열은 사용자가 애플리케이션에 로그인하기 위해 제출해야 하는 로그인 자격 증명입니다. first_name 및 last_name 열에는 사용자의 이름이 저장됩니다.

    custom_prefix(mysql>)
CREATE TABLE system_users (
    user_id BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(50),
    first_name VARCHAR(50),
    last_name VARCHAR(50),
    password VARCHAR(50)
) ENGINE = InnoDB;

  5. 다음 출력을 확인하여 새로운 테이블이 생성되었는지 확인하세요:

    출력
    Query OK, 0 rows affected (0.03 sec)

  6. 샘플 데이터로 system_users 테이블을 채우세요. 보안을 위해 MySQL 내장 MD5(...) 함수를 사용하여 비밀번호를 해시화하세요:

    1. INSERT INTO system_users (username, first_name, last_name, password) VALUES ('john_doe', 'JOHN', 'DOE', MD5('password_1'));

    2. INSERT INTO system_users (username, first_name, last_name, password) VALUES ('mary_henry', 'MARY', 'HENRY', MD5('password_2'));

    3. INSERT INTO system_users (username, first_name, last_name, password) VALUES ('peter_jade', 'PETER', 'JADE', MD5('password_3'));

  7. 아래 출력을 확인하세요:

    출력
    쿼리 성공, 영향을 받은 행: 1개 (0.00초)

  8. system_users 테이블에서 데이터가 올바르게 있는지 쿼리하세요:

    1. SELECT

    2.     user_id,

    3.     first_name,

    4.     last_name,

    5.     password

    6. FROM system_users;

  9. 다음 결과를 확인하십시오:

    결과
    +---------+------------+-----------+----------------------------------+
| user_id | first_name | last_name | password                         |
+---------+------------+-----------+----------------------------------+
|       1 | JOHN       | DOE       | 57210b12af5e06ad2e6e54a93b1465aa |
|       2 | MARY       | HENRY     | 259640f97ac2b4379dd540ff4016654c |
|       3 | PETER      | JADE      | 48ef85c894a06a4562268de8e4d934e1 |
+---------+------------+-----------+----------------------------------+
3 행 in set (0.00 sec)

  10. MySQL 데이터베이스에서 로그 아웃:

    1. QUIT;

이제 애플리케이션에 적합한 MySQL 데이터베이스를 설정했습니다. 다음 단계에서는 샘플 데이터베이스와 통신하는 Python 모듈을 작성합니다.

단계 3 – Python용 중앙 MySQL 게이트웨이 모듈 생성

Python 프로젝트를 작성할 때마다 코드의 재사용성을 높이기 위해 각 작업에 대해 별도의 모듈을 생성해야 합니다. 이 단계에서는 Python 스크립트에서 MySQL 데이터베이스에 연결하고 쿼리할 수 있는 중앙 모듈을 설정합니다. 아래 단계를 따르세요:

  1. project 디렉토리를 생성합니다. 이 디렉토리는 Python 소스 코드 파일을 시스템 파일과 분리합니다:

    1. mkdir project

  2. 새로운 project 디렉토리로 이동하세요:

    1. cd project

  3. nano 텍스트 편집기를 사용하여 mysql_db.py 파일을 엽니다. 이 파일은 Python 모듈로써 MySQL 데이터베이스와 통신합니다:

    nano mysql_db.py

  4. 다음 정보를 mysql_db.py 파일에 입력하세요. company_user 계정의 올바른 MySQL 암호로 example-mysql-password를 대체하세요:

    ~/project/mysql_db.py
    
import mysql.connector

class MysqlDb:

def db_con(self):

    mysql_con = mysql.connector.connect(
        host     = "localhost",
        user     = "company_user",
        password = "예시-MySQL-비밀번호",
        database = "company",
        port     = "3306"
    )

    return mysql_con

def query(self, username, password):

    db = self.db_con()
    db_cursor = db.cursor()

    db_query  = "select username, password from system_users where username = %s and password = md5(%s)"
    db_cursor.execute(db_query, (username, password))

    result = db_cursor.fetchone()
    row_count = db_cursor.rowcount

    if  row_count < 1:
        return False
    else:
        return result[1]

  5. mysql_db.py 파일을 저장하고 닫으십시오.

mysql_db.py 모듈 파일에는 두 개의 메소드(MysqlDb:)를 가진 하나의 클래스가 있습니다:
– db_con(self):, 이전에 생성한 샘플 company 데이터베이스에 연결하여 재사용 가능한 MySQL 연결을 반환하는 return mysql_con 문을 사용합니다.
– query(self, username, password):, username과 password를 인수로 받아 system_users 테이블을 쿼리하여 일치하는 사용자가 있는지 확인하는 메소드입니다. 조건문인 if row_count < 1: ... else: return result[1] 문은 테이블에 사용자가 없는 경우 불리언 값 False을 반환하거나 일치하는 사용자의 비밀번호(result[1])를 반환합니다.

MySQL 모듈이 준비되었으면, 다음 단계를 따라 Redis 키-값 저장소와 통신하는 비슷한 Redis 모듈을 설정하십시오.

단계 4 — 파이썬을 위한 중앙 Redis 모듈 생성

이 단계에서는 Redis 서버에 연결하는 모듈을 작성합니다. 다음 단계를 실행하십시오:

  1. 새로운 redis_db.py 파일을 엽니다:

    nano redis_db.py

  2. redis_db.py 파일에 다음 정보를 입력하십시오. Redis 서버의 올바른 비밀번호로 example-redis-password를 대체하십시오:

    ~/project/redis_db.py
    import redis
class RedisDb:
    def db_con(self):
        r_host = 'localhost'
        r_port = 6379
        r_pass = 'example-redis-password'
        redis_con = redis.Redis(host = r_host, port = r_port, password = r_pass)
        return redis_con

  3. redis_db.py 파일을 저장하고 닫으십시오.

  • 위의 파일에는 클래스 하나(RedisDb:)가 있습니다.

  • 이 클래스에서 db_con(self): 메서드는 제공된 인증 정보를 사용하여 Redis 서버에 연결하고 return redis_con 문을 사용하여 재사용 가능한 연결을 반환합니다.

Redis 클래스를 설정한 후, 다음 단계에서 프로젝트의 메인 파일을 생성하십시오.

단계 5 — 애플리케이션의 진입점 생성

모든 Python 애플리케이션은 진입점 또는 애플리케이션이 실행될 때 실행되는 메인 파일이 있어야 합니다. 이 파일에서는 인증된 사용자를 위해 현재 서버의 시간을 표시하는 코드를 작성합니다. 이 파일은 사용자를 인증하기 위해 생성한 사용자 정의 MySQL 및 Redis 모듈을 사용합니다. 아래 단계를 따라 파일을 생성하십시오:

  1. 새로운 index.py 파일을 엽니다:

    nano index.py

  2. 다음 정보를 index.py 파일에 입력하세요:

    ~/project/index.py
    from encodings import utf_8
import base64
from hashlib import md5
import json
import datetime
import http.server
from http import HTTPStatus
import socketserver
import mysql_db
import redis_db

class HttpHandler(http.server.SimpleHTTPRequestHandler):
    def do_GET(self):
        self.send_response(HTTPStatus.OK)
        self.send_header('Content-type', 'application/json')
        self.end_headers()
        authHeader = self.headers.get('Authorization').split(' ');
        auth_user, auth_password = base64.b64decode(authHeader[1]).decode('utf8').split(':')
        mysql_server = mysql_db.MysqlDb()
        redis_server = redis_db.RedisDb()
        redis_client =  redis_server.db_con()
        now = datetime.datetime.now()
        current_time = now.strftime("%Y-%m-%d %H:%M:%S")
        resp = {}
        if redis_client.exists(auth_user):
            if md5(auth_password.encode('utf8')).hexdigest() != redis_client.get(auth_user).decode('utf8'):
                resp = {"error": "잘못된 사용자 이름/비밀번호입니다."}
            else:
                resp = {"time": current_time, "authorized by": "Redis 서버"}
        else:
            mysql_resp  = mysql_server.query(auth_user, auth_password)
            if mysql_resp == False:
                 resp =  {"error": "잘못된 사용자 이름/비밀번호입니다."}
            else:
                resp = {"time": current_time, "authorized by": "MySQL 서버"}
                redis_client.set(auth_user, mysql_resp)
        self.wfile.write(bytes(json.dumps(resp, indent = 2) + "\r\n", "utf8"))
httpd = socketserver.TCPServer(('', 8080), HttpHandler)
print("웹 서버가 8080 포트에서 실행 중입니다...")

try:
    httpd.serve_forever()
except KeyboardInterrupt:
    httpd.server_close()
    print("웹 서버가 중지되었습니다.")

  3. index.py 파일을 저장하고 닫으세요.

  • index.py 파일에서 import... 섹션에 다음 모듈을 프로젝트에 추가하세요:

    • utf_8, base64, md5, 그리고 json 모듈, 텍스트 인코딩 및 포맷팅 모듈입니다.

    • http.server, HTTPStatus, 그리고 socketserver 모듈, 웹 서버 모듈입니다.

    • datetime 모듈, 시간/날짜 모듈입니다.

    • mysql_db와 redis_db 모듈, 이전에 만든 MySQL과 Redis 서버에 접근하기 위한 사용자 정의 모듈입니다.

  • HttpHandler(http.server.SimpleHTTPRequestHandler)는 HTTP 서버를 위한 핸들러 클래스입니다. 이 클래스 내에서 do_GET(self) 메서드는 인증된 사용자를 위해 HTTP GET 요청을 처리하고 시스템의 날짜/시간을 표시합니다.

  • if ... : else: ... 로직에서 Python 스크립트는 논리적으로 if redis_client.exists(auth_user) 문을 실행하여 사용자의 자격 증명이 Redis 서버에 있는지 확인합니다. 사용자 세부 정보가 존재하고 Redis 저장된 암호가 사용자가 제출한 암호와 일치하지 않으면 응용 프로그램은 {"error": "Invalid username/password."} 오류를 반환합니다.

Redis 서버에 사용자 세부정보가 없으면, 애플리케이션은 mysql_resp = mysql_server.query(auth_user, auth_password) 문을 사용하여 MySQL 데이터베이스 서버에 쿼리를 실행합니다. 사용자가 제공한 비밀번호가 데이터베이스에 저장된 값과 일치하지 않는 경우, 애플리케이션은 {"error": "유효하지 않은 사용자명/비밀번호입니다."} 오류를 반환합니다. 그렇지 않은 경우, 애플리케이션은 redis_client.set(auth_user, mysql_resp) 문을 사용하여 사용자의 세부정보를 Redis 서버에 캐시합니다.

  • 사용자 자격 증명이 Redis/MySQL 세부 정보와 일치하는 모든 경우, 응용 프로그램은 {"time": current_time, ...} 문을 사용하여 시스템의 현재 날짜/시간을 표시합니다. 출력의 authorized by 항목을 통해 응용 프로그램에서 사용자를 인증하는 데이터베이스 서버를 확인할 수 있습니다.

      if redis_client.exists(auth_user):
      if md5(auth_password.encode('utf8')).hexdigest() != redis_client.get(auth_user).decode('utf8'):
          resp = {"error": "유효하지 않은 사용자 이름/비밀번호입니다."}
      else:
          resp = {"time": current_time, "authorized by": "Redis 서버"}
  else:
      mysql_resp  = mysql_server.query(auth_user, auth_password)
      if mysql_resp == False:
           resp =  {"error": "유효하지 않은 사용자 이름/비밀번호입니다."}
      else:
          resp = {"time": current_time, "authorized by": "MySQL 서버"}
          redis_client.set(auth_user, mysql_resp)

이제 응용 프로그램의 주 파일을 설정했습니다. 다음 단계에서는 응용 프로그램을 테스트합니다.

단계 6 — 응용 프로그램 테스트

이 단계에서는 Redis 캐싱 메커니즘이 작동하는지 확인하기 위해 응용 프로그램을 실행합니다. 아래 명령을 실행하여 응용 프로그램을 테스트하세요:

  1. 다음 python3 명령을 사용하여 응용 프로그램을 실행하세요:

    python3 index.py

  2. 응용 프로그램의 사용자 정의 웹 서버가 실행 중인지 확인하세요:

    출력
    웹 서버가 포트 8080..에서 실행 중입니다.

  3. 새 터미널 창에서 서버에 대한 SSH 연결을 설정하고 다음 curl 명령을 실행하여 john_doe의 자격 증명을 사용하여 네 개의 GET 요청을 보냅니다. http://localhost:8080/ URL 끝에 [1-4]를 추가하여 네 개의 요청을 한 번의 명령으로 보냅니다:

    curl -X GET -u john_doe:password_1  http://localhost:8080/[1-4]

  4. 다음 출력을 확인하세요. MySQL 서버는 첫 번째 인증 요청만 처리합니다. 그런 다음 Redis 데이터베이스가 다음 세 개의 요청을 처리합니다.

    출력
    [1/4]
{
  "time": "2023-11-07 10:04:38",
  "authorized by": "MySQL 서버"
}
[4/4]
{
  "time": "2023-11-07 10:04:38",
  "authorized by": "Redis 서버"
}

원하는 대로 응용 프로그램 로직이 작동합니다.

결론

이 가이드에서는 Redis 서버를 사용하여 사용자의 로그인 자격 증명을 캐시하는 Python 애플리케이션을 구축했습니다. Redis는 매우 가용성이 높고 확장 가능한 데이터베이스 서버로, 초당 수천 건의 트랜잭션을 수행할 수 있습니다. 애플리케이션에서 Redis 캐싱 메커니즘을 사용하면 백엔드 데이터베이스 서버의 트래픽을 크게 줄일 수 있습니다. Redis 애플리케이션에 대해 더 자세히 알아보려면 Redis 튜토리얼을 참조하십시오.

Source:
https://www.digitalocean.com/community/tutorials/how-to-speed-up-python-mysql-application-session-handling-with-redis-on-ubuntu-22-04