반응형

파이썬 REST API 개발 및 활용 완벽 가이드

웹 브라우저 말고도,
모바일 앱이나 외부 시스템에서도 우리 Flask 게시판을 사용할 수 있다면 얼마나 좋을까요?
그 해답은 바로 REST API입니다!

 

 

안녕하세요! 😊

Flask 기반 웹 게시판 프로젝트 여섯째 날입니다.

오늘은 웹 프론트엔드만이 아닌, 외부 클라이언트에서도 사용할 수 있는 REST API 개발을 함께 배워보려고 해요.

예를 들어,

우리가 만든 게시판 기능을 모바일 앱이나 다른 백엔드 서비스에서도 활용하고 싶다면 어떻게 해야 할까요?

그 해답은 바로 Flask를 이용한 RESTful API 구축이에요.

이번 시간에는 REST의 기본 개념부터 시작해 Flask에서 JSON 데이터를 주고받는 API 만들기,

그리고 게시판 CRUD API를 직접 구현해보는 실습까지 차근차근 진행할게요.

어렵지 않아요. 이미 우리가 만든 게시판 로직을 바탕으로 하니까 훨씬 수월하게 느껴질 거예요.

그럼 시작해볼까요?

 

1. RESTful API란 무엇인가요? 🤔

요즘 웹 개발에서 REST API라는 말을 자주 들어보셨을 거예요.

그만큼 백엔드 서비스를 설계할 때 꼭 알아야 할 중요한 개념이죠.

하지만 처음 들었을 땐 뭔가 복잡하고 어려워 보일 수 있어요.

그래서 이번에는 RESTful API의 핵심 개념을 쉽고 간단하게 정리해드릴게요!

REST의 핵심 개념은?

  • Resource(자원): REST는 웹의 모든 것을 자원으로 봅니다. 예를 들어 게시글(post), 사용자(user) 같은 것이죠.
  • URI(Uniform Resource Identifier): 자원을 식별하는 주소입니다. 예: /api/posts
  • HTTP 메서드: 자원에 대한 동작을 정의합니다. 예: GET(조회), POST(생성), PUT/PATCH(수정), DELETE(삭제)

REST API는 왜 이렇게 인기가 많을까요?

REST API가 널리 쓰이는 이유는 간단해요.

간결하고 직관적인 구조 덕분이죠.

복잡한 규약 없이 HTTP의 기본 동작만으로 다양한 클라이언트와 쉽게 통신할 수 있으니까요.

또한, REST API는 다음과 같은 특징들을 가지고 있어요:

  1. 🎯 Stateless(무상태성): 각 요청은 독립적이며, 서버는 이전 요청의 상태를 저장하지 않아요.
  2. 🔄 Cacheable: 응답은 캐싱이 가능하므로 성능을 높일 수 있어요.
  3. 🧩 Uniform Interface: 표준화된 인터페이스 덕분에 다양한 플랫폼에서 사용할 수 있어요.

RESTful API 설계시 고려사항은? 🧐

RESTful하게 API를 설계하기 위해 지켜야 할 몇 가지 규칙이 있어요.

특히 초보자들이 자주 놓치는 부분들을 짚어볼게요.

  • URL은 복수형 명사로: 예를 들어 게시글이면 /api/posts와 같이 작성하는 것이 좋습니다.
  • HTTP 상태 코드 정확히 사용: 예를 들어, 성공은 200, 생성은 201, 오류는 400 또는 404 등으로 클라이언트에게 명확히 알려줘야 해요.
  • JSON 응답은 일관성 있게: 예를 들어 항상 {"id": 1, "title": "...", "content": "..."}와 같은 형식 유지

REST API는 단순히 엔드포인트만 만든다고 되는 게 아니라,

일관성과 예측 가능성을 고려해 설계해야 클라이언트가 편하게 쓸 수 있어요.

이게 바로 진짜 백엔드 개발자의 센스겠죠? 😉

 

 

2. Flask에서 REST API 만들기 🔧

자, 이제 본격적으로 Flask로 REST API를 만들어볼까요?

사실 Flask에서는 별도의 라이브러리 없이도 API를 쉽게 만들 수 있어요.

jsonify() 함수와 request.get_json() 메서드만 잘 활용하면 되거든요.

기본 API 예제

가장 기본적인 API는 이렇습니다.

“/api/hello”에 GET 요청을 보내면 JSON 형식으로 인사 메시지를 돌려주는 간단한 코드예요.

from flask import Flask, jsonify

app = Flask(__name__)

@app.route("/api/hello", methods=["GET"])
def hello_api():
    return jsonify(message="안녕하세요! 여기는 Flask REST API입니다.")

 

이렇게 간단한 코드만으로도 API가 완성돼요.

응답은 자동으로 Content-Type: application/json을 포함하므로 별도 설정도 필요 없답니다.

POST 요청 처리 - 클라이언트로부터 JSON 받기

POST 요청은 클라이언트가 서버에 데이터를 보낼 때 사용합니다.

아래처럼 request.get_json()으로 JSON 데이터를 받아 처리할 수 있어요.

from flask import request

@app.route("/api/echo", methods=["POST"])
def echo_api():
    data = request.get_json()
    name = data.get("name", "익명")
    return jsonify(message=f"{name}님, 안녕하세요!")

 

  • request.get_json(): JSON 데이터를 받아서 Python dict로 변환해줘요.
  • jsonify(): dict를 JSON으로 변환해서 응답해줍니다.

 

💡 확장 라이브러리는 쓸까 말까?

Flask는 기본 기능만으로도 API 작성이 가능하지만, 더 복잡한 구조나 반복을 줄이려면 Flask-RESTful 같은 확장을 쓸 수도 있어요.

하지만 지금은 기초 개념을 제대로 익히는 것이 중요하므로, 확장 없이 직접 구현해볼게요.

 

즉, JSON 처리에 필요한 최소한의 도구만으로도 강력한 API를 만들 수 있다는 점!

Flask의 가장 큰 매력이자 초보자에게 추천하는 이유이기도 해요.

 

 

3. JSON 응답 및 요청 처리 방식 📦

REST API에서 데이터를 주고받을 때 가장 흔히 사용하는 형식이 바로 JSON입니다.

Flask에서는 JSON 처리가 매우 간단하면서도 직관적이에요.

이번엔 JSON 응답을 어떻게 만들고, 클라이언트의 JSON 요청 데이터를 어떻게 처리하는지를 정리해볼게요.

1️⃣ JSON 응답 만들기

HTML을 반환하던 일반 웹 뷰와 달리,

API에서는 Python의 딕셔너리 데이터를 JSON 문자열로 변환해서 반환합니다.

Flask에서는 jsonify()를 사용하면 딕셔너리를 자동으로 JSON 형식으로 바꿔주고,

Content-Typeapplication/json으로 지정해줍니다.

from flask import jsonify

@app.route("/api/greet")
def greet():
    return jsonify({
        "status": "success",
        "message": "API가 정상 작동 중입니다."
    })
  • jsonify()는 자동으로 application/json MIME 타입과 200 OK 상태 코드를 설정합니다.

2️⃣ 클라이언트 JSON 요청 처리하기

클라이언트가 보내는 JSON 데이터를 받으려면 request.get_json() 메서드를 사용합니다.

이때 Content-Typeapplication/json으로 설정되어 있어야 해요.

from flask import request

@app.route("/api/submit", methods=["POST"])
def submit_data():
    data = request.get_json()
    name = data.get("name")
    age = data.get("age")
    if not name or not age:
        return jsonify(error="Missing fields"), 400
    return jsonify(message=f"{name}님({age}세), 데이터가 잘 수신되었습니다.")

 

get_json()을 통해 클라이언트의 JSON 요청을 dict로 파싱하고, 데이터 유효성 검사까지 함께 처리할 수 있어요.

3️⃣ 잘못된 요청 처리하기

API는 언제나 올바르지 않은 요청을 고려해야 합니다.

예를 들어

JSON 필드가 빠졌거나 잘못된 값이 들어오면, 클라이언트에게 명확한 메시지와 함께 400 Bad Request를 반환해야 하죠.

 

이런 식으로 API의 응답 일관성을 유지하는 것이 사용자 경험을 높이는 핵심 포인트입니다!

🔓 참고: CORS(Cross-Origin Resource Sharing)

프론트엔드가 다른 도메인(예: React 앱)에서 API를 호출할 경우 CORS 문제가 발생할 수 있어요.

이럴 땐 Flask-CORS 확장을 사용하면 아주 쉽게 해결할 수 있습니다.

# 설치
pip install flask-cors

# 사용 예
from flask_cors import CORS
app = Flask(__name__)
CORS(app)

 

 

4. 게시판 CRUD API 설계 및 구현 📝

이제 본격적으로 게시판 기능을 REST API 형태로 구현해볼 차례입니다.

이전까지는 HTML 페이지를 렌더링해 사용자에게 보여주는 방식이었다면,

이번에는 데이터를 JSON으로 주고받는 API 방식으로 확장합니다.

같은 기능이지만 'API형 백엔드'로 구현한다는 점에서 의미가 커요!

📌 API 엔드포인트 설계

Method URL 설명
POST /api/posts 게시글 생성
GET /api/posts 게시글 목록 조회
GET /api/posts/<id> 게시글 상세 조회
PUT /api/posts/<id> 게시글 수정
DELETE /api/posts/<id> 게시글 삭제

🔨 주요 기능별 구현 예제

1. 게시글 생성 - POST /api/posts

@app.route("/api/posts", methods=["POST"])
def create_post():
    data = request.get_json()
    title = data.get("title")
    content = data.get("content")
    if not title or not content:
        return jsonify(error="필수 입력값 누락"), 400
    new_post = Post(title=title, content=content)
    db.session.add(new_post)
    db.session.commit()
    return jsonify(post_id=new_post.id), 201

2. 게시글 목록 - GET /api/posts

@app.route("/api/posts", methods=["GET"])
def get_posts():
    posts = Post.query.order_by(Post.id.desc()).all()
    result = [post.to_dict() for post in posts]
    return jsonify(posts=result)

 

to_dict()는 모델 클래스에 미리 정의해두어야 합니다.

예: return {"id": self.id, "title": self.title, ...}

3. 게시글 상세조회 - GET /api/posts/<id>

@app.route("/api/posts/<int:post_id>", methods=["GET"])
def get_post(post_id):
    post = Post.query.get(post_id)
    if not post:
        return jsonify(error="존재하지 않는 게시글입니다."), 404
    return jsonify(post=post.to_dict())

4. 게시글 수정 - PUT /api/posts/<id>

@app.route("/api/posts/<int:post_id>", methods=["PUT"])
def update_post(post_id):
    post = Post.query.get(post_id)
    if not post:
        return jsonify(error="해당 게시글 없음"), 404
    data = request.get_json()
    post.title = data.get("title", post.title)
    post.content = data.get("content", post.content)
    db.session.commit()
    return jsonify(message="수정 완료", post=post.to_dict())

5. 게시글 삭제 - DELETE /api/posts/<id>

@app.route("/api/posts/<int:post_id>", methods=["DELETE"])
def delete_post(post_id):
    post = Post.query.get(post_id)
    if not post:
        return jsonify(error="해당 게시글 없음"), 404
    db.session.delete(post)
    db.session.commit()
    return jsonify(message="삭제 완료")

 

 

5. 실습: API 테스트와 사용 예시 🧪

API를 만들었으면 이제는 잘 작동하는지 테스트해봐야겠죠?

우리가 만든 REST API는 브라우저에서는 GET 요청 정도만 직접 확인할 수 있어요.

하지만 POST, PUT, DELETE 같은 요청은 curl이나 Postman 같은 도구로 테스트하는 게 일반적입니다.

🖥 curl 명령어로 API 테스트

  • GET 요청 - 게시글 목록 확인:
    curl -X GET http://localhost:5000/api/posts
  •  
  • POST 요청 - 새 게시글 생성:
    curl -X POST -H "Content-Type: application/json" -d '{"title":"첫 글", "content":"안녕하세요"}' http://localhost:5000/api/posts

🧪 Postman 사용 팁

Postman은 GUI 기반의 API 테스트 도구예요.

HTTP 메서드 선택, 요청 바디 JSON 입력, 응답 확인을 아주 편리하게 할 수 있습니다.

  1. Postman 실행 후 새 요청(Request) 생성
  2. Method: POST, URL: http://localhost:5000/api/posts
  3. Body 탭 → raw → JSON 선택 후 아래 내용 입력: 
  4.  
  5. { "title": "Postman 테스트", "content": "이건 Postman에서 보낸 글이에요." }
  6. Send 버튼 클릭 → 응답 확인!

✅ 예외 케이스 테스트하기

  • 존재하지 않는 게시글을 조회:
    GET /api/posts/99999 → 404 응답 확인
  •  
  • 필수 필드 누락 POST 요청 보내기 → 400 Bad Request 응답 확인

테스트를 반복하면서 우리 API가 얼마나 잘 짜여져 있는지 실감하게 되실 거예요.

오류 메시지도 일관성 있게 만들었다면 더더욱 멋지죠! 😉

 

 

6. 다양한 클라이언트와의 연동 시나리오 📱

지금까지 우리는 Flask 기반 게시판 API를 설계하고 구현하고, 테스트까지 마쳤어요.

이제는 다양한 클라이언트에서 이 API를 어떻게 활용할 수 있을지에 대해 살펴보는 시간입니다.

단순히 웹 브라우저뿐 아니라 모바일 앱, 프론트엔드 자바스크립트, 다른 백엔드 서비스 등과 연동되는 시나리오를 떠올려볼 수 있어요.

🧩 JavaScript에서 AJAX로 API 호출

가장 흔한 연동 방식은 웹 페이지에서 자바스크립트를 이용해 AJAX 방식으로 API를 호출하는 거예요.

예를 들어, HTML 페이지에서 아래처럼 Javascript의 fetch API를 사용할 수 있죠.

fetch("/api/posts")
  .then(response => response.json())
  .then(data => {
    console.log("게시글 목록:", data.posts);
  });

 

이렇게 하면 서버에서 JSON으로 반환한 게시글 목록을 자바스크립트에서 받아와 자유롭게 화면에 뿌릴 수 있어요.

📱 Flutter, React Native 같은 모바일 앱에서 연동

모바일 앱도 마찬가지예요.

백엔드에서 제공한 REST API를 HTTP 통신 모듈 (예: Flutter의 http 패키지, React Native의 axios)로 호출하면 앱에서도 동일하게 게시글을 CRUD할 수 있답니다.

  • Flutter에서는 http.post(), http.get()으로 JSON 데이터를 보내고 받아요.
  • React Native에서는 axios.post(), axios.get() 방식으로 쉽게 연동 가능해요.

🔗 다른 백엔드 시스템과의 연동

우리가 만든 Flask API는 마이크로서비스 구조에서도 활용할 수 있어요.

예를 들어,

사용자 인증은 Django가 담당하고, 게시판 기능은 Flask가 담당하는 식으로 서비스별 역할을 분리해서 통신하는 구조를 만들 수도 있어요.

🚀 실전 팁

  1. API 응답 형식은 항상 일관되게 유지하세요. (예: {"status": "success", "data": ...})
  2. 클라이언트가 다양한 환경에서 호출하는 만큼, CORS 설정은 반드시 고려해야 해요.
  3. API 문서화도 중요합니다! Swagger UI 또는 Postman Collection 등 활용해보세요.

 

이제 우리가 만든 Flask 백엔드는 웹, 앱, 서버 어디서든 활용 가능한 멋진 API 서비스가 되었어요.

여기까지 잘 따라오셨다면 이미 여러분은 초보 탈출 성공! 🎉

 

 

마무리 ✨

이번 여섯째 날 학습에서는 우리가 만든 게시판 웹 애플리케이션을 RESTful API로 확장하는 방법을 익혔습니다.

단순히 기능을 구현하는 것에서 한 걸음 더 나아가, 다양한 클라이언트와 연동 가능한 백엔드 서비스로 발전시키는 데 성공했어요.

REST API의 핵심 개념부터 Flask에서의 실제 구현, JSON 데이터 처리 방식, 그리고 Postman과 curl을 통한 실전 테스트까지 모든 과정을 실습하며 직접 체험해보셨을 텐데요, 어떠셨나요?

좀 더 현업 백엔드 개발자처럼 느껴지지 않으셨나요?

 

이제 여러분의 Flask 웹 서비스는 단지 브라우저에서만 동작하는 게 아니라, 앱, JS 프론트, 외부 시스템 등 어디에서든 자유롭게 사용할 수 있는 API 플랫폼이 된 거예요.

다음 시간에는 이 API를 어떻게 응용할 수 있을지, 또 성능 향상이나 인증 같은 고급 기능도 배워보면 좋겠죠?

 

혹시 아직 익숙하지 않은 부분이 있다면, 실습한 코드를 천천히 다시 보면서 정리해보세요.

반복이 최고의 선생님이니까요 😊

다음 단계에서 또 만나요!

반응형
반응형

파이썬과 Flask로 만드는 게시판 CRUD 완벽 가이드 💻🛠️

게시글을 웹에서 직접 작성하고 수정하고 삭제까지?
Flask와 SQLAlchemy만 있으면 가능합니다!
이 글 하나면 게시판 CRUD 구현은 완전 정복할 수 있어요.

 

 

안녕하세요, 여러분 😊

오늘은 Flask 웹 애플리케이션에서 가장 많이 사용되는 기능 중 하나인 CRUD(Create, Read, Update, Delete)를 직접 구현해볼 거예요.

단순히 이론 설명에서 그치는 게 아니라, 실제 웹 브라우저에서 게시글을 작성하고 목록을 보고, 수정하거나 삭제하는 완전한 게시판 시스템을 만들 거예요.

이 과정을 통해 Flask와 ORM(SQLAlchemy)의 활용 방법을 보다 실제적인 방식으로 배워보게 될 거예요.

기초부터 차근차근, 코드 한 줄 한 줄 이해하며 따라올 수 있게 구성했으니, 초보자도 걱정 말고 끝까지 함께 해봐요! 😉

 

1. 게시글 작성 기능 구현 (Create 기능) 📝

웹 게시판에서 가장 먼저 구현할 기능은 게시글 작성입니다.

사용자가 직접 제목과 내용을 입력하고 저장 버튼을 누르면, 해당 내용이 데이터베이스에 저장되고 목록이나 상세 페이지로 이동하게 만들 거예요.

우선 기본적인 흐름을 코드와 함께 살펴볼게요.

① 글 작성 폼 구현

`/board/new` 경로로 GET 요청 시 사용자에게 제목과 내용 입력란을 보여주는 HTML 폼을 렌더링합니다.

아래는 템플릿 예시입니다:

<form method="POST">
  <label>제목</label><br>
  <input type="text" name="title"><br>
  <label>내용</label><br>
  <textarea name="content"></textarea><br>
  <button type="submit">작성하기</button>
</form>

 

CSRF 방지와 보안은 이후 단계에서 `Flask-WTF` 같은 라이브러리를 통해 보완할 예정입니다.

지금은 기본적인 기능 흐름을 먼저 구현해보는 데 집중할게요!

② POST 요청 처리 및 DB 저장

사용자가 작성한 제목과 내용을 받아 `Post` 모델을 통해 DB에 저장합니다.

아래는 Flask 라우트 코드 예시예요:

@app.route('/board/new', methods=['GET', 'POST'])
def create_post():
    if request.method == 'POST':
        title = request.form['title']
        content = request.form['content']

        if not title or not content:
            flash('제목과 내용을 모두 입력해주세요.')
            return redirect(url_for('create_post'))

        post = Post(title=title, content=content)
        db.session.add(post)
        db.session.commit()

        flash('게시글이 작성되었습니다.')
        return redirect(url_for('post_detail', post_id=post.id))

    return render_template('create_post.html')

③ 피드백과 리다이렉트

작성 후에는 목록 페이지 또는 상세 페이지로 이동하며 flash를 통해 사용자에게 피드백 메시지를 전달할 수 있습니다.

템플릿에서 아래와 같이 메시지를 출력할 수 있어요:

{% with messages = get_flashed_messages() %}
  {% if messages %}
    <ul>
    {% for message in messages %}
      <li>{{ message }}</li>
    {% endfor %}
    </ul>
  {% endif %}
{% endwith %}

🧪 실습 포인트

  • 제목 또는 내용을 비워서 제출했을 때 적절히 에러 처리가 되는지 확인해보세요.
  • 글 작성 후 DB에 제대로 저장되었는지 SQLAlchemy로 직접 쿼리하거나 목록 페이지에서 확인해보세요.
  • 작성 후 이동된 페이지에서 flash 메시지가 출력되는지 확인해보세요.

여기까지 구현하면 웹을 통해 실제로 글을 작성하고, 그것이 DB에 저장되는 전체 흐름을 직접 체험해볼 수 있어요.

다음은 작성된 글들을 조회해보는 기능, 목록 페이지로 넘어가볼게요!

 

 

2. 게시글 목록 조회 페이지 구현 (Read - 목록) 📋

게시판의 중심이 되는 페이지는 바로 목록 페이지입니다.

작성된 게시글들을 사용자에게 보여주는 역할을 하며, 각 게시글의 제목을 클릭하면 상세 페이지로 이동할 수 있어야 해요.

오늘은 이 목록 페이지를 Flask와 SQLAlchemy로 어떻게 구성할 수 있는지 하나씩 살펴보겠습니다.

① 목록 라우트 구현

/board 경로에서 모든 게시글을 조회할 수 있도록 라우트를 구현합니다.

작성일자를 기준으로 내림차순 정렬해 가장 최신 글이 위로 오도록 할 거예요.

@app.route('/board')
def post_list():
    posts = Post.query.order_by(Post.created_at.desc()).all()
    return render_template('post_list.html', posts=posts)

② 템플릿에서 게시글 목록 출력

게시글 데이터를 HTML에서 반복문을 통해 출력합니다.

게시글 제목을 클릭하면 상세 페이지로 이동하도록 링크를 걸어주세요.

<h2>게시글 목록</h2>
<ul>
  {% for post in posts %}
    <li>
      <a href="{{ url_for('post_detail', post_id=post.id) }}">{{ post.title }}</a>
      ({{ post.created_at.strftime('%Y-%m-%d %H:%M') }})
    </li>
  {% else %}
    <li>작성된 게시글이 없습니다.</li>
  {% endfor %}
</ul>

 

작성일이 보이도록 strftime을 활용해 날짜 포맷을 지정하는 것도 사용자 편의에 도움이 돼요.

③ (선택) 페이지네이션 기능 소개

글이 많아졌을 경우 모든 글을 한 페이지에 보여주는 것은 비효율적이에요.

이럴 땐 페이지네이션을 도입할 수 있습니다.

Flask-SQLAlchemy에서는 아래와 같이 페이지당 몇 개의 게시글을 보여줄지 설정할 수 있어요:

@app.route('/board')
def post_list():
    page = request.args.get('page', 1, type=int)
    posts = Post.query.order_by(Post.created_at.desc()).paginate(page=page, per_page=10)
    return render_template('post_list.html', posts=posts.items, pagination=posts)

 

실습에서는 구현하지 않아도 되지만, 프로젝트가 커질 경우 꼭 필요한 기능이에요.

Flask-Paginate 확장도 한 번 찾아보세요!

🧪 실습 포인트

  • 게시글 여러 개를 작성한 뒤, 최신 순으로 잘 정렬되는지 확인해보세요.
  • 게시글 제목을 클릭했을 때 해당 글의 상세 페이지로 잘 이동되는지 확인해보세요.
  • 아무 글도 없을 때 ‘게시글이 없습니다’ 문구가 표시되는지도 테스트해보세요.

이제 목록 페이지도 완성되었네요!

다음은 하나의 게시글을 눌렀을 때 나오는 상세 보기와 수정 기능을 구현해볼 차례입니다. 💪

 

 

3. 게시글 상세 보기 및 수정 기능 구현 (Read/Update) ✏️

게시글 목록에서 사용자가 특정 게시글을 클릭했을 때, 그 게시글의 내용을 보여주는 상세 보기 페이지와, 이후 수정할 수 있는 기능까지 구현해볼 거예요.

이 단계에서는 동적 라우팅, 데이터 조회, 그리고 POST 기반 수정 처리를 중심으로 배워보겠습니다.

① 게시글 상세 보기 페이지 구현

사용자가 게시글 제목을 클릭하면 /board/<post_id> 경로로 이동하도록 구현합니다.

이때 post_id를 기준으로 해당 게시글을 데이터베이스에서 조회해 보여줍니다.

@app.route('/board/<int:post_id>')
def post_detail(post_id):
    post = Post.query.get_or_404(post_id)
    return render_template('post_detail.html', post=post)

 

get_or_404()는 ID에 해당하는 데이터가 없을 경우 자동으로 404 에러를 반환해주기 때문에 안전한 처리 방식입니다.

② 수정 폼 페이지 구현

게시글 상세 페이지에서 ‘수정’ 버튼을 누르면 /board/<post_id>/edit 경로로 이동합니다.

이 경로에서는 기존 게시글 데이터를 폼의 초기값으로 미리 넣어 보여줍니다.

@app.route('/board/<int:post_id>/edit', methods=['GET', 'POST'])
def edit_post(post_id):
    post = Post.query.get_or_404(post_id)
    if request.method == 'POST':
        post.title = request.form['title']
        post.content = request.form['content']

        if not post.title or not post.content:
            flash('빈 칸 없이 입력해주세요.')
            return redirect(url_for('edit_post', post_id=post.id))

        db.session.commit()
        flash('게시글이 수정되었습니다.')
        return redirect(url_for('post_detail', post_id=post.id))

    return render_template('edit_post.html', post=post)

 

POST 요청 시 사용자가 입력한 값으로 기존 객체의 속성을 업데이트하고, db.session.commit()으로 저장합니다.

③ 수정 폼 템플릿 예시

<form method="POST">
  <label>제목</label><br>
  <input type="text" name="title" value="{{ post.title }}"><br>
  <label>내용</label><br>
  <textarea name="content">{{ post.content }}</textarea><br>
  <button type="submit">수정하기</button>
</form>

🧪 실습 포인트

  • 존재하지 않는 게시글 ID로 상세 페이지나 수정 페이지에 접근했을 때 404 오류가 잘 출력되는지 확인해보세요.
  • 수정 후 변경 사항이 목록 페이지나 상세 페이지에 즉시 반영되는지 확인해보세요.
  • 빈 입력값에 대한 처리와 사용자 피드백 메시지가 적절히 작동하는지 체크해보세요.

게시글 수정까지 완료했으니, 이제 남은 마지막 핵심 기능은 삭제입니다!

다음 단계에서는 게시글 삭제 처리 및 후속 처리까지 깔끔하게 구현해볼게요.

 

 

4. 게시글 삭제 기능 구현 (Delete) 🗑️

이제 게시글을 삭제하는 기능을 구현해볼 차례예요.

사용자 인터페이스에서 삭제 버튼을 클릭하면 해당 게시글이 실제로 데이터베이스에서 제거되고, 목록 페이지로 되돌아가게 만들 거예요.

삭제 전 확인 메시지를 띄우는 방법도 함께 알아봅시다.

① 삭제 버튼 추가하기

게시글 상세 페이지나 수정 페이지에서 삭제 버튼을 추가해 사용자가 클릭할 수 있도록 합니다.

아래는 HTML 폼을 사용한 간단한 예시예요:

<form method="POST" action="{{ url_for('delete_post', post_id=post.id) }}" 
      onsubmit="return confirm('정말 삭제하시겠습니까?');">
  <button type="submit">삭제하기</button>
</form>

 

자바스크립트의 confirm() 함수로 간단한 삭제 확인창도 띄워줍니다.

이렇게 하면 실수로 삭제하는 것을 방지할 수 있어요.

② Flask 라우트에서 삭제 처리

삭제 처리는 POST 방식으로 요청을 받아 처리하는 것이 일반적입니다.

아래는 Flask에서 삭제를 처리하는 라우트 예시입니다.

@app.route('/board/<int:post_id>/delete', methods=['POST'])
def delete_post(post_id):
    post = Post.query.get_or_404(post_id)
    db.session.delete(post)
    db.session.commit()
    flash('게시글이 삭제되었습니다.')
    return redirect(url_for('post_list'))

 

get_or_404()를 통해 유효하지 않은 접근은 방지하고, 삭제 후에는 목록 페이지로 리다이렉트하며 플래시 메시지로 피드백을 줍니다.

③ 삭제 후 상태 확인

삭제가 완료되면 목록 페이지에서 해당 글이 사라져야 하고,

삭제된 게시글의 상세 주소로 접근할 경우 404 오류가 발생해야 해요.

이를 통해 삭제가 확실히 이루어졌는지 확인할 수 있습니다.

🧪 실습 포인트

  • 게시글 삭제 시 confirm 창이 잘 뜨는지 확인해보세요.
  • 삭제 후 목록 페이지에서 해당 글이 사라지는지 확인해보세요.
  • 삭제된 게시글 URL에 다시 접근했을 때 404 페이지가 나오는지도 꼭 확인해보세요.

이제 CRUD의 마지막 조각까지 완성되었습니다!

다음 단계에서는 전체 흐름을 다시 정리하고, CRUD를 어떻게 확장할 수 있을지에 대한 인사이트도 함께 나눠볼게요. 😊

 

 

5. CRUD 전체 사이클 정리 및 테스트 💡

지금까지 우리는 Flask와 SQLAlchemy를 활용해 게시판 CRUD 기능을 하나하나 구현해봤어요.

작성(Create), 조회(Read), 수정(Update), 삭제(Delete)까지 모든 사이클을 직접 경험하면서 웹 애플리케이션의 기본기를 탄탄하게 익혔습니다.

이 섹션에서는 전체 흐름을 다시 정리해보고, 실습 시 꼭 확인해야 할 테스트 항목들도 체크해볼게요.

① CRUD 사이클 요약 정리

기능 라우팅 설명
작성 (Create) /board/new 폼을 통해 게시글 생성, DB에 저장
조회 (Read - 목록) /board 모든 게시글을 리스트로 조회
조회 (Read - 상세) /board/<id> 단일 게시글을 ID로 조회
수정 (Update) /board/<id>/edit 기존 글을 수정하여 업데이트
삭제 (Delete) /board/<id>/delete 해당 게시글을 DB에서 삭제

② 전체 기능 테스트 체크리스트 ✅

  • 글 작성 시 제목과 내용이 비어 있으면 경고 메시지가 표시되는가?
  • 목록에서 최신 글이 가장 위에 오는가?
  • 상세 페이지에서 제목, 내용, 작성 시간이 제대로 보이는가?
  • 수정 시 기존 내용이 폼에 미리 채워지고, 수정 후 정상 반영되는가?
  • 삭제 후 목록에서 글이 사라지고, 삭제된 글 URL 접근 시 404가 나오는가?

③ 다음 단계 미리 보기 👀

CRUD 기능은 웹 애플리케이션의 핵심 기초라고 할 수 있어요.

이후에는 이 기능들을 REST API 형태로 제공하거나, JavaScript를 활용해 비동기로 처리하는 등 다양한 확장으로 이어질 수 있어요. 예를 들어:

  • 게시판을 API 형태로 만들어 React, Vue 같은 프론트엔드 프레임워크와 연동하기
  • JWT 로그인 기능과 결합해 작성자 인증/권한 부여 기능 추가하기
  • 댓글 기능, 파일 첨부 기능 등 게시판 고도화

이번 CRUD 구현이 단순한 끝이 아니라, 앞으로 나아갈 가능성의 출발점이라는 걸 꼭 기억해 주세요!

 

 

6. 마무리 및 다음 단계 안내 🚀

여기까지 따라오신 여러분 정말 수고 많으셨습니다! 👏

Flask와 SQLAlchemy를 사용한 게시판 CRUD 기능 구현을 하나하나 직접 해보며, 웹 애플리케이션 개발의 핵심 흐름을 완전히 익히셨을 거예요.

처음에는 생소했던 라우팅, 폼 데이터 처리, 데이터베이스 모델, 커밋과 쿼리 등 다양한 개념이 이제는 자연스럽게 느껴지실 겁니다.

이 CRUD 구현 경험은 이후의 모든 웹 개발 여정에 있어서 든든한 뼈대가 되어줄 거예요.

 

이번 실습을 통해 익힌 기술은 단순한 기능 구현을 넘어서, 실제 서비스를 만들고 유지보수하는 데에도 큰 도움이 됩니다.

 

그리고 여기서 끝이 아니에요!

다음 단계에서는 이 CRUD 기능들을 RESTful API로 전환하고, 프론트엔드와 연결하거나, 인증 기능을 넣는 방법도 배울 수 있어요.

웹 개발자로서 한 단계 더 도약할 수 있는 기반이 다져진 거죠. 😎

 

꼭 한 번 CRUD 기능을 자신만의 프로젝트에 적용해보세요.

예를 들어,

  • 나만의 블로그 만들기
  • 간단한 TODO 앱이나 일기장 만들기
  • Flask와 React를 연동한 게시판 프로젝트 도전하기

앞으로도 꾸준히 연습하고 발전해 나가면, 어떤 웹 서비스도 직접 만들 수 있게 될 거예요.

우리는 이제 시작입니다! 😄

반응형
반응형

파이썬 ORM과 데이터베이스 연동 (SQLAlchemy)

데이터를 손쉽게 저장하고 꺼낼 수 있다면 얼마나 편할까요?
SQL 없이 파이썬 객체만으로 DB를 다룰 수 있는 방법,
지금 바로 알아보세요!

 

 

안녕하세요, 여러분!

Flask 웹 개발의 핵심 기능 중 하나는 바로 데이터베이스 연동이죠.

특히 게시판, 블로그, 사용자 시스템 등에서 데이터를 저장하고 불러오는 기능은 필수입니다.

오늘은 ORM(Object Relational Mapping) 개념부터 Flask-SQLAlchemy를 활용한 실제 데이터베이스 연동까지, 실습 중심으로 하나씩 차근차근 배워볼 거예요.

SQLite를 사용해 복잡한 환경 설정 없이 시작하고, 직접 모델을 정의하고 테이블을 생성해보며 ORM의 편리함을 체감해보세요.

실습 예제를 따라하면서 여러분만의 데이터 저장 시스템을 만들어봅시다!

 

1. ORM과 SQLAlchemy란? 🧠

여러분은 SQL 문을 일일이 작성하며 데이터를 관리하던 경험, 있으신가요?

테이블 생성, 삽입, 조회, 수정, 삭제… 이 모든 작업을 SQL 없이 파이썬 객체만으로 할 수 있다면 얼마나 편할까요?

바로 그걸 가능하게 해주는 기술이 ORM (Object Relational Mapping)입니다.

ORM이란 무엇인가요?

ORM은 객체 지향 프로그래밍(OOP)과 관계형 데이터베이스(RDB)를 연결해주는 브릿지 역할을 합니다.

즉, 테이블 → 클래스, 레코드 → 객체로 매핑해주는 거죠.

파이썬 클래스와 객체를 통해 데이터를 조작하고 관리할 수 있어, 마치 메모리 내 객체를 다루듯 DB 작업을 수행할 수 있습니다.

 

ORM은 단순히 편리함을 넘어서, 유지보수성과 재사용성, 보안성까지 함께 높여줍니다.

  • SQL 문법을 몰라도 DB 조작이 가능해요
  • DB 변경이 생겨도 코드 수정 최소화
  • 보안상 SQL 인젝션 위험이 줄어듭니다

SQLAlchemy란?

SQLAlchemy는 파이썬에서 가장 널리 쓰이는 ORM 프레임워크입니다.

SQL을 완전히 추상화하여 객체 기반으로 DB 작업을 할 수 있게 도와주죠.

특히 다양한 DBMS(예: MySQL, PostgreSQL, SQLite, Oracle 등)를 지원하여 확장성 면에서도 매우 강력합니다.

Flask에서는 Flask-SQLAlchemy라는 확장 라이브러리를 통해 SQLAlchemy를 더 쉽고 간편하게 사용할 수 있어요.

SQLAlchemy의 핵심 특징

특징 설명
ORM + Core 지원 ORM 방식과 SQL 직접 작성 방식 모두 지원
다양한 DB 지원 SQLite, MySQL, PostgreSQL 등 거의 모든 RDBMS 사용 가능
모델 클래스 매핑 파이썬 클래스와 DB 테이블 자동 매핑
세션 기반 트랜잭션 세션을 통한 트랜잭션 관리로 안전한 작업 가능

실습에서는 SQLite를 사용해볼 거예요.

설치가 필요 없고 파일 기반으로 바로 실행되니까 입문자에게 최적이거든요!

 

2. Flask-SQLAlchemy 설정 방법 ⚙️

ORM 개념과 SQLAlchemy에 대해 이해했다면, 이제 실전입니다!

Flask 애플리케이션에서 Flask-SQLAlchemy를 설정하고 SQLite와 연결해 보겠습니다.

1️⃣ Flask-SQLAlchemy 설치하기

pip install flask flask_sqlalchemy

Flask는 이미 설치되어 있다고 가정하고, flask_sqlalchemy만 설치하면 준비 완료입니다!

2️⃣ 데이터베이스 구성 설정

Flask 앱에서 SQLAlchemy를 사용하려면, 먼저 DB URI를 설정해야 합니다.

이번 실습에서는 SQLite를 사용하므로 다음과 같은 설정이 필요합니다:

# app.py 또는 config.py 파일 내
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///board.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
  • sqlite:///board.db: 현재 프로젝트 폴더에 board.db 파일 생성
  • SQLALCHEMY_TRACK_MODIFICATIONS: 변경 추적 기능 비활성화 (경고 방지)

3️⃣ SQLAlchemy 초기화

설정을 마쳤다면 Flask 애플리케이션에 SQLAlchemy를 초기화해야 합니다.

SQLAlchemy 객체를 생성한 후 Flask 앱과 연결하는 방식으로 진행합니다.

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///board.db'


# MySQL 연결 예시 (사용 시 주석 해제)
# app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://사용자이름:비밀번호@호스트주소:포트/데이터베이스이름'
# 예시: app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://root:password@localhost:3306/board_db'

# MariaDB 연결 예시 (사용 시 주석 해제)
# app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://사용자이름:비밀번호@호스트주소:포트/데이터베이스이름'
# 예시: app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://root:password@localhost:3306/board_db'


app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

db = SQLAlchemy(app)

MySQL이나 MariaDB를 Flask + SQLAlchemy로 연결할 때는 pymysql 또는 mysqlclient 같은 DB 드라이버필수입니다.

SQLAlchemy는 ORM이지만, 실제 DB와 통신은 Python용 DB 드라이버가 처리합니다. 즉,

  • SQLAlchemy는 DB 쿼리를 객체화하고,
  • pymysql 같은 드라이버가 실제 DB와 연결해주는 역할을 합니다.

✅ MySQL / MariaDB에서 가능한 드라이버

드라이버 URI 접두어 설치 방법 특징
pymysql mysql+pymysql:// pip install pymysql Pure Python, 호환성 높음
mysqlclient mysql+mysqldb:// pip install mysqlclient C기반, 속도 빠름
asyncmy mysql+asyncmy:// pip install asyncmy 비동기 FastAPI 등에서 활용

 

이렇게 하면 이후에 정의할 모델 클래스들이 자동으로 앱과 연결되어 DB와 상호작용하게 됩니다.

이제 준비가 끝났어요!

다음 단계에서는 실제로 게시글(Post) 모델을 정의하고 테이블과 매핑하는 과정을 배워볼게요.

 

 

3. 데이터 모델 정의와 테이블 매핑 📄

이제 본격적으로 ORM의 핵심 기능인 데이터 모델 정의에 들어갑니다.

여기서는 게시판의 핵심 데이터인 게시글을 관리하는 Post 모델을 만들고, 이 모델이 데이터베이스의 테이블과 어떻게 연결되는지를 알아볼 거예요.

📌 모델 클래스 만들기

SQLAlchemy에서는 DB 테이블을 Python 클래스 형태로 정의합니다.

모델 클래스는 db.Model을 상속하며, 클래스 변수로 각 필드를 정의합니다.

예를 들어 게시글(Post) 모델은 다음과 같이 만들 수 있어요:

from flask_sqlalchemy import SQLAlchemy
from datetime import datetime

db = SQLAlchemy()

class Post(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100), nullable=False)
    content = db.Column(db.Text, nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
  • id: 기본 키(PK), 자동 증가 정수
  • title: 게시글 제목, 최대 100자, 필수 입력
  • content: 본문 내용, 긴 텍스트 가능, 필수 입력
  • created_at: 글 생성 시간, 자동으로 현재 시간 저장

🧩 선택: 사용자 모델과 관계 설정

시간 관계상 본 과정에서는 인증 기능을 구현하지 않지만, 관계형 DB에서는 모델 간 연결도 아주 중요합니다.

예를 들어 User와 Post 모델을 연결하면 다음과 같은 식으로 구성할 수 있어요.

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)

class Post(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100), nullable=False)
    content = db.Column(db.Text, nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
    user = db.relationship('User', backref='posts')

ForeignKeyrelationship을 통해 일대다 관계를 명시할 수 있고,

이를 통해 ORM에서 연관 데이터를 자연스럽게 다룰 수 있어요.

 

이제 모델도 정의했으니, 다음 단계에서는 데이터베이스에 테이블을 실제로 생성하고 마이그레이션 도구를 통해 구조를 관리하는 방법을 배워볼게요.

 

 

4. 모델 간의 관계 설정하기 🔗

ORM의 진짜 강점은 복잡한 테이블 간 관계를 객체 지향적으로 관리할 수 있다는 점이에요.

특히 게시판처럼 게시글과 사용자, 댓글 등이 연결된 구조에서는 ForeignKeyrelationship 기능이 아주 유용합니다.

🔐 관계형 데이터베이스의 기본

관계형 데이터베이스에서는 여러 테이블 간에 관계를 설정해 데이터 중복을 줄이고, 데이터 무결성을 유지할 수 있습니다.

대표적인 관계는 다음과 같아요.

관계 유형 예시
일대일 (One-to-One) User ↔ Profile
일대다 (One-to-Many) User → Post
다대다 (Many-to-Many) Post ↔ Tag

👥 User ↔ Post 관계 구현 예제

이번 예시에서는 한 명의 유저(User)가 여러 개의 게시글(Post)을 작성할 수 있는 일대다(1:N) 관계를 설정해봅니다.

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)

class Post(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100), nullable=False)
    content = db.Column(db.Text, nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
    user = db.relationship('User', backref='posts')
  • user_id: 외래 키(ForeignKey)로 User 테이블의 id와 연결
  • relationship: Post 인스턴스에서 user 접근, User 인스턴스에서 posts 접근 가능

이제 한 유저가 작성한 모든 게시글을 user.posts로 가져올 수 있고, 게시글에서 작성자를 post.user로 확인할 수 있어요. 정말 직관적이지 않나요?

 

다음 단계에서는 이렇게 정의한 모델을 기반으로 실제 DB에 테이블을 생성하고 Flask-Migrate로 스키마 변경을 관리하는 방법을 알아보겠습니다.

 

 

5. 마이그레이션 도구로 테이블 관리하기 🔄

ORM을 사용해서 모델을 정의했으면, 그걸 기반으로 실제 데이터베이스 테이블을 만드는 작업이 필요합니다.

Flask에서는 db.create_all()을 통해 간단하게 테이블을 생성할 수 있어요.

하지만 실전 개발에서는 마이그레이션 도구를 사용하는 게 더 안전하고 유연합니다.

🛠 db.create_all()으로 초기 테이블 만들기

db.create_all()은 개발 초기 한 번만 사용하는 테이블 생성 함수입니다.

모델 정의가 끝난 후 다음 코드를 실행하면 해당 테이블이 SQLite에 생성됩니다.

from your_app_name import db

db.create_all()

하지만 테이블 구조가 바뀔 때마다 다시 DB를 지우고 만들 순 없잖아요? 그래서 Flask-Migrate를 사용하는 겁니다.

🧬 Flask-Migrate로 안전하게 관리하기

Flask-Migrate는 SQLAlchemy 기반 모델의 변경 사항을 추적하고,

DDL(SQL 명령어) 형태로 자동 변환해서 DB에 적용해주는 도구입니다.

Alembic이라는 강력한 마이그레이션 툴 위에 구축되어 있어요.

설치 및 설정

pip install flask-migrate
from flask_migrate import Migrate

migrate = Migrate(app, db)

이제 커맨드라인 명령을 통해 마이그레이션을 생성하고 적용할 수 있어요.

마이그레이션 명령어 모음

명령어 설명
flask db init 마이그레이션 폴더 초기화
flask db migrate -m "Initial migration" 모델 변경사항을 감지해 마이그레이션 파일 생성
flask db upgrade 실제 DB에 변경사항 반영

upgrade 명령이 완료되면 DB에 posts, users 등 테이블이 생성되어 있을 거예요.

직접 DB 파일을 열어보면 더욱 실감 나겠죠?

 

이제 테이블도 준비 완료!

다음은 이 모델과 테이블을 실제로 다뤄보는 실습 시간입니다.

데이터를 생성하고 저장하고, 다시 불러오는 전 과정을 직접 해볼 거예요.

 

 

6. 실습: 데이터 생성, 저장, 조회 🧪

드디어 지금까지 준비한 모델과 테이블을 바탕으로 실제 데이터를 생성하고 조회해볼 시간입니다.

이번 실습에서는 Flask Shell을 활용해 ORM의 기본 동작을 직접 체험해 볼 거예요.

📥 Flask Shell 실행하기

터미널에서 아래 명령어를 입력하면 Flask 앱의 컨텍스트에서 ORM 객체를 바로 사용할 수 있습니다.

flask shell

그 다음 아래처럼 게시글 데이터를 만들어보고 저장해볼 수 있어요.

>>> from app import db
>>> from models import Post
>>> post = Post(title="첫 번째 글", content="ORM으로 저장된 글입니다!")
>>> db.session.add(post)
>>> db.session.commit()

위 코드로 데이터베이스에 게시글 하나가 저장됩니다.

별도의 SQL 없이도 Python 객체를 통해 저장할 수 있는 게 ORM의 묘미죠!

🔍 저장된 게시글 조회하기

조회는 더 간단해요.

query 속성을 사용하면 모든 데이터를 불러오거나, 조건을 걸어 하나만 찾을 수도 있죠.

>>> Post.query.all()
>>> Post.query.filter_by(title="첫 번째 글").first()
  • all(): 전체 데이터 리스트 조회
  • filter_by(): 조건 검색 (WHERE 절)

📤 데이터를 삭제하거나 수정하려면?

삭제와 수정도 역시 객체 기반으로 처리할 수 있습니다.

SQL 없이도 데이터를 조작할 수 있으니 정말 직관적이에요.

>>> post = Post.query.get(1)
>>> post.title = "제목 수정됨"
>>> db.session.commit()

>>> db.session.delete(post)
>>> db.session.commit()

정말 쉽죠?

SQL이 필요 없는 이 간편함, ORM을 배우는 가장 큰 이유라고 해도 과언이 아닙니다.

 

이제 Flask와 ORM, 그리고 SQLite를 활용해서 기본적인 CRUD(생성, 조회, 수정, 삭제) 작업을 모두 수행할 수 있게 되었어요!

이걸 바탕으로 다음 시간에는 뷰 함수와 연결된 게시판 기능을 구현하게 될 거예요.

 

 

마무리 🎯

지금까지 Flask 애플리케이션에서 ORM을 사용해 데이터베이스와 연동하는 과정을 처음부터 끝까지 살펴봤습니다.

ORM의 개념 이해부터 SQLAlchemy 설치, 모델 정의, 관계 설정, 마이그레이션, 그리고 실전 테스트까지...

꽤 많은 걸 함께 해봤네요.

 

SQL을 몰라도 객체 지향적으로 DB를 다룰 수 있다는 점, 그리고 마치 파이썬 코드만으로 모든 데이터를 조작할 수 있다는 게 ORM의 가장 큰 장점이에요.

 

이제 여러분은 Flask에서 SQLite를 활용해 동적인 데이터를 저장하고, 불러오고, 수정하고, 삭제할 수 있는 기반을 갖췄어요.

다음 단계에서는 이 데이터들을 기반으로 사용자에게 보여주는 인터페이스,

뷰 함수와 템플릿을 통해 웹페이지에서 게시글 목록과 내용을 직접 확인하고 조작하는 방법을 배울 거예요.

 

여기까지 오신 여러분, 정말 고생 많으셨어요.

직접 코드를 실행하고 테스트해보면서 익히면 훨씬 더 오래 기억에 남을 거예요. 그럼 다음 단계에서 다시 만나요!

반응형

+ Recent posts