반응형

장고(Django)로 쉽고 빠르게 Todo 리스트 앱 만들기 🚀

장고 초보자라면 이 글 하나만으로 Todo 앱 구현의 모든 것을 마스터할 수 있어요.
같이 만들어볼까요?
반응형

 

안녕하세요, 여러분!

오늘도 함께 성장하는 블로그, First Step입니다. 이번 포스트에서는 Django로 직접 Todo 리스트 웹 애플리케이션을 만드는 과정을 차근차근 알아볼 거예요.

저도 처음 Django를 접했을 때, 모델을 만들고 데이터베이스에 저장하는 과정이 헷갈렸던 기억이 나네요.

여러분은 그런 고민 없이 바로 이해하고 따라 할 수 있도록 쉬운 설명과 실습을 준비했습니다.

함께 손을 움직이며 직접 경험해 보면 어느새 CRUD 기능이 익숙해질 거예요!

 

1. TodoItem 모델 생성과 마이그레이션 🔧

모든 웹 애플리케이션에서 가장 중요한 부분 중 하나는 바로 데이터를 어떻게 다루는지, 즉 데이터 모델을 설정하는 방법이에요. Django에서는 이 모델을 데이터베이스와 자동으로 연동시켜주는 아주 편리한 ORM(Object-Relational Mapping) 기능이 있어서 여러분이 데이터베이스를 잘 몰라도 쉽게 데이터를 관리할 수 있어요.

📌 TodoItem 모델 정의하기

먼저 프로젝트 폴더 내의 앱 폴더로 들어가서 models.py 파일을 열고 다음과 같이 모델을 정의해볼게요.

from django.db import models

class TodoItem(models.Model):
    title = models.CharField(max_length=200)  # Todo 항목 제목
    content = models.TextField()              # Todo 항목 내용
    created_at = models.DateTimeField(auto_now_add=True)  # 생성된 날짜 및 시간 자동 기록

    def __str__(self):
        return self.title
  • title: 할 일의 제목을 입력하는 필드로 최대 200자까지 입력 가능해요.
  • content: Todo에 대한 상세 내용을 입력할 수 있는 텍스트 필드에요.
  • created_at: Todo 항목이 언제 만들어졌는지 자동으로 날짜와 시간이 저장되는 필드에요.

📌 모델 마이그레이션 실행하기

이제 이 모델을 데이터베이스에 실제로 반영해 볼 거예요. Django는 간단한 명령어 몇 줄만으로 이 작업을 자동으로 해줘서 참 편리해요. 터미널을 열고 프로젝트 폴더 내에서 다음 명령어를 차례대로 입력해 보세요.

python manage.py makemigrations
python manage.py migrate

위의 명령어를 실행하면, makemigrations는 모델에서의 변경 사항을 감지하고, 이를 기록하는 파일을 생성해요. 이후 migrate 명령어는 이 기록을 실제 데이터베이스에 적용하는 과정이랍니다.

✔️ 마이그레이션 확인하기

마이그레이션이 정상적으로 완료되었는지 확인하려면, Django Admin 페이지에 접속하거나 Django 쉘을 사용해서 모델 객체를 만들어보는 방법이 있어요. Admin 페이지에 접속하는 방법은 다음 단계에서 더 자세히 알아볼게요!

 

여기까지 따라 하셨다면 축하드려요! 🎉 이제 실제 데이터를 다룰 수 있는 모델이 준비됐습니다. 다음 단계에서는 이 데이터를 화면에 어떻게 출력할 수 있는지 알아볼게요!

 

 

2. Todo 항목 목록 조회 📋

모델이 준비됐으니, 이제 실제로 데이터베이스에 저장된 Todo 항목들을 화면에 출력해 볼까요? 목록 조회는 데이터베이스에 저장된 데이터를 불러와서 웹 페이지에 표시하는 기본적이면서도 꼭 필요한 작업이에요. Django에서는 이 과정을 아주 깔끔하게 처리할 수 있어요. 제가 처음 Django를 접했을 때 데이터가 화면에 출력되는 걸 보고 신기했던 기억이 나네요.

📌 목록 뷰(List View) 함수 만들기

먼저 앱 폴더 안에 있는 views.py 파일을 열고 아래 코드를 입력해서 데이터베이스에서 Todo 항목들을 불러오는 함수를 작성해볼게요.

from django.shortcuts import render
from .models import TodoItem

def todo_list(request):
    todos = TodoItem.objects.all().order_by('-created_at')  # 생성일 기준 최신 순으로 정렬
    context = {
        'todos': todos
    }
    return render(request, 'todo/todo_list.html', context)
  • TodoItem.objects.all(): 데이터베이스에 저장된 모든 Todo 항목을 불러오는 Django ORM 메서드예요.
  • order_by('-created_at'): 가장 최근에 추가된 Todo 항목이 맨 위에 오도록 생성일을 기준으로 정렬해요.

📌 URL 설정하기

다음으로는 이 뷰 함수를 웹에서 접근할 수 있도록 URL을 설정할 차례예요. urls.py 파일을 앱 폴더에 만들어서 다음 코드를 작성해주세요.

from django.urls import path
from . import views

urlpatterns = [
    path('', views.todo_list, name='todo_list'),
]

📌 템플릿 파일 만들기(todo_list.html)

이제 실제 화면에 Todo 항목을 출력하는 템플릿을 만들 거예요. 프로젝트 폴더 내 템플릿 폴더(templates/todo/)를 만들고 todo_list.html 파일을 추가해 아래와 같이 작성해 볼게요.

<!-- todo_list.html -->
<h1>Todo 목록</h1>
<ul>
    {% for todo in todos %}
        <li>{{ todo.title }} - {{ todo.created_at }}</li>
    {% empty %}
        <li>할 일이 없어요!</li>
    {% endfor %}
</ul>

이렇게 준비가 끝나면 브라우저에서 Django 서버를 실행하고 웹 페이지를 접속해 보세요. 이제 실제로 데이터베이스에 저장된 Todo 항목들이 화면에 예쁘게 나타나는 것을 확인할 수 있을 거예요. 🎉

 

다음 단계에서는 각 Todo 항목의 상세 정보를 볼 수 있는 뷰를 만드는 방법을 알아볼게요. 기대해 주세요!

 

 

3. 개별 Todo 항목 상세 보기 🔍

목록을 통해 Todo 항목들이 잘 보이는 것까지 성공했어요! 하지만 실제 앱에서는 각각의 항목을 클릭하면 더 자세한 내용을 볼 수 있어야겠죠? 이번 단계에서는 개별 Todo 항목을 클릭했을 때, 제목과 내용을 상세하게 보여주는 상세 보기(Detail View)를 만들어볼 거예요.

📌 상세 뷰(Detail View) 함수 만들기

먼저 views.py 파일에 다음과 같이 상세 뷰 함수를 추가해볼게요.

from django.shortcuts import render, get_object_or_404
from .models import TodoItem

def todo_detail(request, pk):
    todo = get_object_or_404(TodoItem, pk=pk)
    context = {
        'todo': todo
    }
    return render(request, 'todo/todo_detail.html', context)
  • get_object_or_404: 요청한 항목이 없을 경우 자동으로 404 에러를 표시하는 아주 편리한 Django 내장 함수예요.

📌 상세보기 URL 설정하기

이제 방금 만든 상세보기 뷰를 연결해 주기 위해 앱의 urls.py 파일에 다음 코드를 추가해 주세요.

from django.urls import path
from . import views

urlpatterns = [
    path('', views.todo_list, name='todo_list'),
    path('todo/<int:pk>/', views.todo_detail, name='todo_detail'),
]
  • URL에서 <int:pk> 부분은 각 Todo 항목의 고유한 ID(primary key)를 전달받는 부분이에요.

📌 상세보기 템플릿 파일(todo_detail.html) 작성하기

마지막으로 템플릿 폴더 내에 todo_detail.html을 만들어 다음과 같이 작성해주세요.

<!-- todo_detail.html -->
<h1>{{ todo.title }}</h1>
<p>{{ todo.content }}</p>
<p>생성일: {{ todo.created_at }}</p>
<a href="{% url 'todo_list' %}">목록으로 돌아가기</a>

이제 목록 페이지에서 각 Todo 항목을 클릭하면, 해당 Todo의 상세 정보 페이지로 이동하는 기능이 잘 동작할 거예요! 🎯

 

다음 단계는 Todo를 생성하는 방법을 알아보는 단계예요. 계속해서 함께 달려볼까요? 🏃‍♂️💨

 

 

4. ModelForm으로 새로운 Todo 추가하기 📝

지금까지 Todo 목록을 조회하고 개별 항목의 상세 정보까지 확인했어요. 이제는 웹 페이지에서 직접 새로운 Todo 항목을 추가하는 기능을 만들어볼 거예요. 이때 Django의 ModelForm을 사용하면 정말 쉽게 입력 폼을 만들 수 있답니다.

📌 ModelForm 정의하기

앱 디렉토리 안에 forms.py 파일을 만들고 아래처럼 작성해볼게요.

from django import forms
from .models import TodoItem

class TodoForm(forms.ModelForm):
    class Meta:
        model = TodoItem
        fields = ['title', 'content']
  • fields: 폼에서 입력 받을 필드를 지정해요. 여기서는 제목과 내용만 입력받아요.

📌 생성(Create) 뷰 만들기

이제 실제 폼을 보여주고 입력값을 처리할 뷰를 만들어볼까요? views.py에 추가합니다.

from django.shortcuts import render, redirect
from .forms import TodoForm

def todo_create(request):
    if request.method == 'POST':
        form = TodoForm(request.POST)
        if form.is_valid():
            form.save()
            return redirect('todo_list')
    else:
        form = TodoForm()
    return render(request, 'todo/todo_form.html', {'form': form})

📌 URL 설정하기

URL 패턴도 추가해줘야겠죠? 앱의 urls.py에 아래 코드를 추가해주세요.

path('todo/new/', views.todo_create, name='todo_create'),

📌 입력 폼 템플릿(todo_form.html) 작성하기

폼 화면을 구성하는 템플릿을 만들어 볼게요. 아래와 같이 templates/todo/todo_form.html을 작성하세요.

<!-- todo_form.html -->
<h1>새로운 Todo 추가하기</h1>

<form method="post">
    {% csrf_token %}
    {{ form.as_p }}
    <button type="submit">추가하기</button>
</form>

<a href="{% url 'todo_list' %}">목록으로 돌아가기</a>

✔️ 폼 데이터 확인 및 테스트하기

이제 서버를 실행하고 브라우저에서 /todo/new/ 주소로 접속해보세요. 간단한 입력 폼이 잘 나오고, 내용을 입력한 후 추가 버튼을 클릭하면 Todo 항목이 성공적으로 추가되는 것을 볼 수 있어요. 🎉

 

다음 단계에서는 Todo 항목의 수정 및 삭제 기능을 함께 만들어 볼게요. 계속 함께 가요! 🚀

 

 

5. Todo 수정 및 삭제 기능 구현 ✏️🗑️

이제 Todo 앱에서 꼭 필요한 기능인 항목 수정과 삭제 기능을 구현할 차례입니다. 저는 처음 Django를 공부할 때, 이 기능들을 구현하고 나니 정말 뿌듯했던 기억이 있어요. 여러분도 이 단계만 따라 하면 손쉽게 구현할 수 있을 거예요!

📌 수정(Update) 기능 구현하기

views.py 파일에 다음과 같이 수정 뷰를 추가합니다.

from django.shortcuts import render, get_object_or_404, redirect
from .models import TodoItem
from .forms import TodoForm

def todo_update(request, pk):
    todo = get_object_or_404(TodoItem, pk=pk)
    if request.method == 'POST':
        form = TodoForm(request.POST, instance=todo)
        if form.is_valid():
            form.save()
            return redirect('todo_detail', pk=pk)
    else:
        form = TodoForm(instance=todo)
    return render(request, 'todo/todo_form.html', {'form': form})

📌 삭제(Delete) 기능 구현하기

이번에는 삭제 기능을 구현해 볼까요? 간단한 삭제 확인 화면을 추가해 사용자가 실수로 항목을 삭제하지 않도록 해줄게요.

def todo_delete(request, pk):
    todo = get_object_or_404(TodoItem, pk=pk)
    if request.method == 'POST':
        todo.delete()
        return redirect('todo_list')
    return render(request, 'todo/todo_confirm_delete.html', {'todo': todo})

📌 URL 추가하기

수정과 삭제를 위한 URL을 앱의 urls.py에 추가하세요.

path('todo/<int:pk>/edit/', views.todo_update, name='todo_update'),
path('todo/<int:pk>/delete/', views.todo_delete, name='todo_delete'),

📌 삭제 확인 템플릿 작성하기

삭제 확인을 위한 템플릿 todo_confirm_delete.html을 작성하세요.

<!-- todo_confirm_delete.html -->
<h1>정말 삭제할까요?</h1>
<p>삭제할 Todo: {{ todo.title }}</p>

<form method="post">
    {% csrf_token %}
    <button type="submit">네, 삭제할게요</button>
    <a href="{% url 'todo_detail' todo.pk %}">취소</a>
</form>

이제 Todo 항목 상세 페이지에서 수정 및 삭제 링크를 추가해 테스트해보세요. 모든 기능이 정상적으로 작동하면 드디어 기본적인 CRUD 기능이 완성된 거예요! 🎉

 

다음 마지막 단계에서는 개발한 전체 기능을 종합적으로 테스트하고 마무리할게요. 거의 다 왔습니다! 🥳

 

 

6. 개발한 Todo 앱의 CRUD 동작 테스트 ✅

자, 여러분! 우리가 지금까지 차근차근 만든 Todo 앱의 모든 CRUD(Create, Read, Update, Delete) 기능이 제대로 동작하는지 마지막 테스트를 해볼 시간이에요. 솔직히 제가 Django를 배우면서 이 순간이 가장 설렜던 것 같아요. 직접 만든 기능들이 제대로 동작하는 걸 볼 때의 성취감, 다들 느껴보셨죠? 😄

📌 1단계: Todo 추가 기능 테스트

  • 브라우저에서 /todo/new/ 주소에 접속해 새로운 Todo 항목을 추가해보세요.
  • 입력한 항목이 목록 페이지에서 정상적으로 표시되는지 확인해보세요.

📌 2단계: 목록 및 상세 조회 기능 테스트

  • 메인 페이지(/)에서 목록이 잘 나타나는지 확인하세요.
  • 목록에서 항목을 클릭해 상세보기 페이지가 잘 열리는지 확인해보세요.

📌 3단계: Todo 수정 기능 테스트

  • 상세보기 페이지에서 "수정하기" 버튼 또는 URL(/todo/{pk}/edit/)을 통해 Todo 항목을 수정해보세요.
  • 수정한 내용이 정확히 반영되었는지 확인하세요.

📌 4단계: Todo 삭제 기능 테스트

  • 상세보기 페이지에서 "삭제하기" 버튼 또는 URL(/todo/{pk}/delete/)로 항목 삭제를 시도하세요.
  • 삭제 후 메인 페이지에서 항목이 사라졌는지 확인하세요.

 

이 모든 기능이 잘 작동했다면 정말 훌륭합니다! 👏

여러분은 Django를 활용해 간단하면서도 강력한 CRUD 웹 애플리케이션을 성공적으로 완성했어요. 스스로를 칭찬해 주세요! 😄

 

 

마무리하며 🎯

지금까지 저와 함께 Django를 사용해서 Todo 리스트 애플리케이션의 모델 정의부터 CRUD 기능 구현까지 차근차근 살펴보았어요. 처음 Django를 접했을 때 복잡하고 어렵게 느껴졌던 부분들이, 이렇게 하나씩 실습하면서 익숙해지셨다면 정말 기쁠 것 같아요. 여러분이 이번 실습을 통해 배운 내용을 응용하면 더 다양한 웹 애플리케이션도 손쉽게 개발할 수 있을 거예요.

 

그럼 다음에도 더 유익하고 재미있는 내용으로 찾아올게요. 끝까지 함께 해주셔서 정말 감사합니다! 😍

📌 이번 실습을 통해 배운 것 요약

  • Django 모델 생성과 마이그레이션 방법
  • Django 뷰 함수 및 템플릿을 활용한 목록, 상세 조회 방법
  • ModelForm을 이용한 데이터 입력 및 유효성 검사 방법
  • Django ORM을 사용한 데이터 수정 및 삭제 기능 구현
반응형
반응형

CRUD 구현과 Todo 앱 개발

여러분, 나만의 Todo 앱, 어렵다고만 느껴졌나요?
오늘은 Django로 누구나 쉽게 만들 수 있도록 친절하게 알려드릴게요!
반응형

 

안녕하세요, 여러분! 😊

오늘은 웹 개발에서 가장 기본이면서도 실습으로 정말 많이 등장하는 CRUD 기능 구현과 Todo 앱 개발을 함께 진행해볼 거예요.

특히 Django 프레임워크를 활용해서 폼(Form) 처리부터 CRUD 사이클을 자연스럽게 익힐 수 있도록 구성했어요.

"Create-Read-Update-Delete"라는 말을 들어본 적은 있지만 실제로 프로젝트에 적용하는 과정이 막막했던 분들,

지금부터 하나씩 차근차근, 꼭 필요한 부분만 쏙쏙 집어서 설명드릴 테니 끝까지 따라와 주세요! 🙌

 

1. CRUD 개념 이해하기 ✨

여러분, CRUD라는 단어, 개발 입문하면서 한 번쯤은 들어보셨죠? 😊

하지만 정확히 어떤 의미인지 헷갈리는 분들도 많더라고요.

그래서 오늘은 아주 쉽게, 그리고 확실하게 정리해드릴게요!

CRUD란 무엇인가요?

  • Create (생성): 새로운 데이터를 만들어요.
  • Read (조회): 저장된 데이터를 읽어와요.
  • Update (수정): 기존 데이터를 수정해요.
  • Delete (삭제): 더 이상 필요 없는 데이터를 지워요.

이 네 가지 행동이 바로 CRUD예요.

거의 모든 웹 애플리케이션은 이 CRUD 사이클을 기반으로 동작한다고 해도 과언이 아니에요!

블로그 글 작성, 댓글 남기기, 쇼핑몰 상품 수정하기, 회원 탈퇴하기... 다 CRUD입니다.

CRUD를 자유자재로 다룰 수 있으면 웹 개발의 70%는 이미 마스터했다고 봐도 무방할 정도예요. 😎

CRUD 흐름, 어떻게 돌아가는 걸까?

  1. 사용자가 폼에 데이터를 입력하고 생성(Create) 요청을 보낸다.
  2. 서버가 데이터베이스에 데이터를 저장한다.
  3. 사용자가 목록을 보거나 검색해서 조회(Read)를 요청한다.
  4. 특정 항목을 수정하고 싶으면 수정(Update) 요청을 보낸다.
  5. 필요 없는 데이터는 삭제(Delete) 요청을 통해 삭제한다.

이렇게 보면 CRUD는 그냥 "데이터를 만들고, 읽고, 고치고, 없애는 것"이죠.

그리고 이 모든 과정을 Django에서는 아주 쉽게 처리할 수 있도록 도와줘요.

(진짜 너무 편해요, 감동할걸요? 😭)

 

즉, CRUD는 웹 서비스의 '심장'이라고 할 수 있습니다.

이 개념을 제대로 이해하고 구현할 수 있어야 제대로 된 웹 애플리케이션을 만들 수 있어요!

 

 

2. Django 폼(Form)과 ModelForm 활용법 📝

CRUD를 제대로 구현하려면 사용자로부터 데이터를 입력받을 수 있어야 해요.

그걸 담당하는 게 바로 폼(Form)입니다.

Django에서는 폼을 정말 쉽게 만들 수 있도록 Form 클래스와 ModelForm 클래스를 제공해줘요.

Form 클래스란?

Form 클래스는 말 그대로 입력 폼을 정의하는 클래스입니다.

입력받을 필드를 직접 하나하나 지정해줘야 해요.

from django import forms

class TodoForm(forms.Form):
    title = forms.CharField(max_length=100)
    content = forms.CharField(widget=forms.Textarea)

이렇게 하면 titlecontent를 입력할 수 있는 폼이 완성돼요!

폼 유효성 검증도 자동으로 해주기 때문에 "빈칸이면 오류" 같은 기본적인 체크도 따로 코딩할 필요가 없어요.

진짜 편하죠? 😆

ModelForm 클래스란?

ModelForm은 Form을 더 쉽게 만들기 위한 강력한 무기예요!

특정 모델(Model)과 연결해서 폼을 자동 생성해주는 클래스거든요.

from django import forms
from .models import Todo

class TodoModelForm(forms.ModelForm):
    class Meta:
        model = Todo
        fields = ['title', 'content']

ModelForm을 쓰면 모델에 정의된 필드 정보로 폼을 알아서 만들어줘요.

그리고 save() 메서드 하나만 호출하면 바로 데이터베이스에 저장까지 끝!

노가다 코딩은 이제 안녕입니다. 👋

Form vs ModelForm 요약

구분 Form ModelForm
특징 필드를 직접 지정 모델을 기반으로 자동 생성
작성 난이도 조금 번거로움 매우 간편
추천 상황 비표준 폼 필요시 모델 기반 CRUD 작업

Tip: CRUD 구현할 때는 대부분 ModelForm을 사용하는 게 훨씬 편하고 효율적입니다! 😎

 

 

3. GET과 POST 요청 흐름 파헤치기 🔄

Django로 폼을 만들었으면 이제 중요한 게 하나 남았어요.

바로 요청(Request) 처리 흐름입니다. 특히 GETPOST 요청을 제대로 이해해야 CRUD 기능을 완성할 수 있어요!

GET 요청: 페이지를 보여주는 요청

GET은 사용자가 페이지를 보러 올 때 보내는 요청이에요.

예를 들어, 글쓰기 폼을 보여줄 때 GET 요청을 사용합니다.

def todo_create(request):
    if request.method == 'GET':
        form = TodoModelForm()
        return render(request, 'todo_form.html', {'form': form})

위 코드를 보면 알겠지만, GET 요청이면 빈 폼을 만들어서 보여줘요.

"폼 열어줘!" 하는 느낌이라고 생각하면 쉽습니다. 😉

POST 요청: 데이터를 제출하는 요청

POST는 사용자가 폼에 입력한 데이터를 제출할 때 보내는 요청이에요.

예를 들어, 글쓰기 버튼을 눌렀을 때 POST 요청이 발생합니다.

def todo_create(request):
    if request.method == 'POST':
        form = TodoModelForm(request.POST)
        if form.is_valid():
            form.save()
            return redirect('todo_list')

POST 요청이면, 폼에 입력된 데이터를 form 객체에 담고, 검증(is_valid())한 뒤, 이상 없으면 save() 메서드로 저장해요!

그리고 저장이 완료되면 redirect()를 사용해 목록 페이지로 이동시켜줍니다.

요약: GET vs POST

요청 종류 역할
GET 폼을 보여준다 (읽기용)
POST 폼 데이터를 제출하고 처리한다 (쓰기용)

이 흐름을 확실히 이해하면, 폼 처리와 CRUD 기능 구현이 정말 쉬워져요!

"GET이면 보여주고, POST면 처리한다" 이 공식만 기억하세요! 😎

 

 

4. 기능별 URL 설계 방법 🛤️

이제 폼도 만들었고, 요청 흐름(GET/POST)도 알게 되었어요.

그럼 다음으로 중요한 건 바로 URL 패턴 설계입니다! 🚀

CRUD 각각의 기능에 맞게 알기 쉬운 URL을 짜야 해요.

사용자가 길을 잃지 않게 해주는 일종의 "표지판" 같은 거죠.

기능별 URL 기본 패턴 ✨

  • 목록 보기(Read) : /todos/
  • 상세 보기(Read) : /todos/<id>/
  • 새로 만들기(Create) : /todos/new/
  • 수정하기(Update) : /todos/<id>/edit/
  • 삭제하기(Delete) : /todos/<id>/delete/

기능별 URL을 이렇게 직관적으로 설계하면, 개발자도 헷갈리지 않고 사용자도 편리하게 이용할 수 있어요.

특히 id를 경로에 포함시키는 부분은 아주 중요합니다!

(어떤 Todo 항목을 수정하거나 삭제할지 구분해야 하니까요.)

Django URL 설정 예시 🛠️

from django.urls import path
from . import views

urlpatterns = [
    path('todos/', views.todo_list, name='todo_list'),
    path('todos/new/', views.todo_create, name='todo_create'),
    path('todos//', views.todo_detail, name='todo_detail'),
    path('todos//edit/', views.todo_update, name='todo_update'),
    path('todos//delete/', views.todo_delete, name='todo_delete'),
]

URL 패턴을 이렇게 깔끔하게 맞춰주면 뷰 함수도 훨씬 체계적으로 관리할 수 있어요.

게다가 name을 지정해주면 나중에 {% url 'todo_list' %} 이런 식으로 템플릿에서 바로 사용 가능!

진짜 효율적입니다. 😎

정리!

  • 기능별로 URL을 명확하게 구분하자.
  • id를 경로에 포함해서 특정 항목을 다루자.
  • name 속성으로 URL 이름을 정해서 템플릿에서도 활용하자.

 

 

5. 클래스 기반 뷰(Generic Views) 살펴보기 🏗️

자, 여기까지 온 여러분! CRUD를 함수 기반 뷰로 처리하는 법은 잘 이해하셨죠? 👏

그런데 Django는 여기서 더 친절하게도 클래스 기반 뷰(Class-Based Views, CBV)라는 걸 제공해요.

특히 Generic Views를 사용하면 CRUD 작업을 훨씬 더 빠르고 깔끔하게 만들 수 있답니다!

Generic Views란 무엇인가요?

Generic View는 Django가 CRUD 작업을 위해 미리 만들어놓은 뷰 클래스를 말해요.

우리는 상속만 받아서 살짝 설정만 해주면, 복잡한 코드를 직접 작성할 필요 없이 CRUD 기능을 자동으로 사용할 수 있어요.

진짜 개발자의 삶의 질이 달라집니다... ✨

대표적인 CRUD Generic View 종류

  • ListView - 객체 목록을 보여줄 때 사용
  • DetailView - 하나의 객체 상세 정보를 보여줄 때 사용
  • CreateView - 새로운 객체를 생성할 때 사용
  • UpdateView - 기존 객체를 수정할 때 사용
  • DeleteView - 객체를 삭제할 때 사용

Generic View 코드 예시 ✍️

from django.views.generic import ListView, CreateView
from .models import Todo

class TodoListView(ListView):
    model = Todo
    template_name = 'todo_list.html'

class TodoCreateView(CreateView):
    model = Todo
    fields = ['title', 'content']
    template_name = 'todo_form.html'
    success_url = '/todos/'

봐요, 진짜 깔끔하죠?

이런 식으로 기본적인 목록보기, 생성하기 기능이 몇 줄 코드만으로 뚝딱 완성됩니다!

정리!

  • 클래스 기반 뷰는 CRUD 작업을 빠르고 쉽게 만든다!
  • ListView, CreateView, UpdateView 등을 잘 활용해보자!

 

6. 미니 Todo 앱 만들기 🗒️

여러분, 드디어 실습 시간이에요! 🎉

지금까지 배운 걸 바탕으로 간단한 미니 Todo 앱을 만들어볼 거예요.

처음엔 복잡해 보여도 걱정 마세요. 하나하나 따라 하면 금방 멋진 결과물이 나옵니다!

1. 모델 생성하기

from django.db import models

class Todo(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.title

제목(title), 내용(content), 생성일(created_at)을 갖는 아주 심플한 모델이에요.

makemigrationsmigrate 명령어로 데이터베이스 반영도 잊지 말기!

2. URL 설정하기

아까 배운 CRUD URL 패턴을 토대로 urls.py를 작성해요!

from django.urls import path
from .views import TodoListView, TodoCreateView, TodoDetailView, TodoUpdateView, TodoDeleteView

urlpatterns = [
    path('todos/', TodoListView.as_view(), name='todo_list'),
    path('todos/new/', TodoCreateView.as_view(), name='todo_create'),
    path('todos//', TodoDetailView.as_view(), name='todo_detail'),
    path('todos//edit/', TodoUpdateView.as_view(), name='todo_update'),
    path('todos//delete/', TodoDeleteView.as_view(), name='todo_delete'),
]

3. 뷰(Views) 작성하기

from django.views.generic import ListView, DetailView, CreateView, UpdateView, DeleteView
from .models import Todo
from django.urls import reverse_lazy

class TodoListView(ListView):
    model = Todo
    template_name = 'todo_list.html'

class TodoDetailView(DetailView):
    model = Todo
    template_name = 'todo_detail.html'

class TodoCreateView(CreateView):
    model = Todo
    fields = ['title', 'content']
    template_name = 'todo_form.html'
    success_url = reverse_lazy('todo_list')

class TodoUpdateView(UpdateView):
    model = Todo
    fields = ['title', 'content']
    template_name = 'todo_form.html'
    success_url = reverse_lazy('todo_list')

class TodoDeleteView(DeleteView):
    model = Todo
    template_name = 'todo_confirm_delete.html'
    success_url = reverse_lazy('todo_list')

4. 템플릿 만들기

각 페이지를 위한 HTML 파일을 작성해야겠죠?

  • todo_list.html (목록 페이지)
  • todo_form.html (작성 및 수정 폼)
  • todo_detail.html (상세보기)
  • todo_confirm_delete.html (삭제 확인)

템플릿은 Django 템플릿 언어(DTL)를 써서 {{ todo.title }} 같은 식으로 데이터를 출력할 수 있어요. 초반에는 간단하게, 차차 예쁘게 꾸며나가면 됩니다. ✨

정리!

  • 모델 → URL → 뷰 → 템플릿 순서대로 개발 진행
  • Generic View를 적극 활용하면 빠르게 개발 가능
  • 완성 후 서버를 돌려 테스트하기!

 

마무리 ✨

자, 여기까지 함께 따라오신 여러분 정말 고생 많으셨습니다! 👏

오늘은 CRUD 개념부터 시작해서 Django의 Form 처리, GET과 POST 요청 흐름, 기능별 URL 설계, 그리고 클래스 기반 뷰(Generic Views)까지 배운 다음, 직접 미니 Todo 앱을 만들어봤어요.

처음에는 막막하게 느껴질 수 있지만, 작은 프로젝트를 하나씩 완성하다 보면 어느 순간 "아, CRUD는 이렇게 돌아가는구나!" 하고 자연스럽게 체득할 수 있습니다. 실전 프로젝트를 만들 때도 오늘 배운 이 흐름을 그대로 활용할 수 있어요.

 

Tip! 👉 오늘 만든 Todo 앱을 조금 더 발전시키고 싶다면?

  • 완료 여부(체크박스)를 추가해보세요 ✅
  • 마감일(deadline) 필드를 추가해 날짜순 정렬을 해보세요 📅
  • 사용자 인증(로그인 기능)을 붙여서 개인별 Todo 관리로 발전시켜보세요 🔐

 

이렇게 한 걸음 한 걸음 업그레이드해 나가면서 실전 웹 개발자로 성장할 수 있습니다! 🚀

오늘도 함께 성장하는 하루였길 바라요. 감사합니다! 🙏

반응형
반응형

Django 모델 생성과 데이터 출력 완전 정복

데이터를 눈으로 확인할 수 있어야 진짜 실력이죠!
Django 모델부터 화면 출력까지 직접 해보는 실습, 지금 시작해볼까요?

 

 

안녕하세요, 여러분!

오늘은 Django 프로젝트에서 데이터 모델을 정의하고, 그 데이터를 실제 웹 페이지에서 출력하는 전 과정을 함께 살펴보려 해요.

예전엔 막연하게 느껴졌던 모델 정의와 마이그레이션, 그리고 admin에서 데이터 입력하고 템플릿에서 출력하는 흐름이 이제는 훨씬 친숙하게 느껴질 거예요.

이 글에서는 TodoItem 또는 BlogPost 같은 간단한 모델을 정의해서, admin 사이트에서 데이터를 넣고, 뷰 함수와 템플릿을 통해 화면에 출력하는 과정까지 단계별로 진행해볼 거예요.

 

1. 모델 정의하기 🧱

자, 이제 Django에서 가장 핵심이라고 할 수 있는 모델(Model)을 만들어볼 차례예요.

모델은 데이터베이스 테이블과 1:1로 매칭되는 클래스로, 우리가 다룰 데이터를 어떤 형태로 저장하고 사용할지를 정의해줍니다.

📝 모델 클래스 생성

예를 들어, 간단한 할 일(Todo) 목록을 만들고 싶다고 해봅시다.

이럴 땐 다음처럼 TodoItem 모델을 정의할 수 있어요:

from django.db import models

class TodoItem(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.title

 

이 모델을 한 줄씩 살펴보면 다음과 같습니다:

필드 설명
title 할 일의 제목 (문자열, 최대 200자)
content 자세한 설명을 담을 수 있는 텍스트 필드
created_at 데이터가 생성된 시간 (자동 저장)

📁 모델 파일 저장 위치

모델 클래스는 보통 각 앱의 models.py 파일에 작성합니다.

예를 들어, 앱 이름이 todo라면 todo/models.py에 위 코드를 추가해 주세요.

  • models.py는 각 앱 안에 존재하며 데이터 구조를 정의하는 핵심 파일이에요.
  • __str__() 메서드는 admin이나 쉘에서 객체를 문자열로 표시할 때 유용합니다.

이렇게 간단한 모델 하나만 정의해도, Django는 이걸 기반으로 데이터베이스 테이블을 만들고 다양한 기능을 자동으로 제공해줘요. 정말 멋지지 않나요?

 

 

2. 마이그레이션 수행하기 🔄

모델을 만들었다고 해서 곧바로 데이터베이스에 테이블이 생기는 건 아니에요.

Django에서는 마이그레이션(migration)이라는 과정을 거쳐야 모델의 정의가 실제 데이터베이스 테이블로 반영됩니다.

🛠️ 마이그레이션 순서

  1. python manage.py makemigrations - 모델 변경 사항을 기반으로 마이그레이션 파일을 생성해요.
  2. python manage.py migrate - 실제로 데이터베이스에 테이블을 만들거나 수정해요.

직접 터미널에서 한 번 입력해볼까요?

# 마이그레이션 파일 생성
$ python manage.py makemigrations

# DB에 실제 반영
$ python manage.py migrate

 

명령어 실행 후 아래와 같이 출력되면 성공입니다 🎉

Migrations for 'todo':
  todo/migrations/0001_initial.py
    - Create model TodoItem

Operations to perform:
  Apply all migrations: admin, auth, contenttypes, sessions, todo
Running migrations:
  Applying todo.0001_initial... OK

🚧 잠깐! 이런 에러가 나올 수 있어요

  • App 'todo' could not be found → settings.py에 앱 등록 안 했을 가능성!
  • No changes detected → 모델을 수정한 적이 없을 수도 있어요.

마이그레이션은 한 번만 하고 끝나는 게 아니라, 모델에 변화가 생길 때마다 반복하게 될 작업입니다.

앞으로 자주 만나게 될 명령어니까 익숙해지는 게 좋아요!

 

 

3. Admin 사이트에 모델 등록하기 ⚙️

모델을 만들고 마이그레이션까지 완료했다면, 이제는 데이터를 직접 추가해볼 수 있어야겠죠?

Django는 기본적으로 Admin 사이트라는 강력한 기능을 제공합니다.

이걸 통해 직접 데이터를 추가하거나 수정할 수 있어요.

✅ 모델을 Admin에 등록하기

우선 admin.py 파일을 열어 아래처럼 코드를 추가해 주세요.

from django.contrib import admin
from .models import TodoItem

admin.site.register(TodoItem)

 

이렇게 하면 Admin 페이지에서 TodoItem 모델을 볼 수 있게 됩니다. 아주 간단하죠?

4. 슈퍼유저 생성 및 데이터 추가 👑

Admin에 로그인하려면 슈퍼유저(superuser) 계정을 먼저 만들어야 해요.

아래 명령어를 입력해 관리자 계정을 만들어 봅시다.

$ python manage.py createsuperuser

 

이제 서버를 실행하고 http://127.0.0.1:8000/admin에 접속해보세요.

  • 로그인하면 TodoItem이 목록에 보일 거예요.
  • 클릭해서 새 데이터도 직접 입력할 수 있답니다.

이제 모델을 만들고, Admin에 등록하고, 데이터를 입력하는 기본적인 백엔드 흐름을 완성했어요!

다음은 이 데이터를 뷰(View)템플릿(Template)을 통해 웹페이지에서 출력해보는 단계입니다.

 

 

5. 뷰 함수에서 QuerySet으로 데이터 조회 📦

Admin에서 입력한 데이터를 웹 페이지에 출력하려면 뷰(View) 함수에서 모델로부터 데이터를 조회해야 해요.

이때 사용하는 게 바로 Django의 ORM 기능 중 하나인 QuerySet입니다.

💡 QuerySet이란?

QuerySet은 데이터베이스에서 가져온 객체들의 집합이에요.

SQL을 직접 쓰지 않고 파이썬 문법으로 데이터를 조회할 수 있도록 도와줍니다.

예를 들어 TodoItem.objects.all()은 TodoItem 테이블의 모든 데이터를 불러오는 명령어랍니다.

🛠 뷰 함수에서 QuerySet 사용하기

자, 이제 views.py 파일에서 실제로 데이터를 가져오는 코드를 작성해볼게요.

from django.shortcuts import render
from .models import TodoItem

def todo_list(request):
    todos = TodoItem.objects.all()  # QuerySet: 전체 데이터 조회
    return render(request, 'todo/list.html', {'todos': todos})
  • TodoItem.objects.all()은 등록된 모든 할 일을 가져옵니다.
  • render() 함수는 데이터를 HTML 템플릿과 함께 반환해요.

🔗 URLconf에 뷰 연결하기

뷰 함수를 만들었으면 해당 함수에 접근할 수 있도록 urls.py에도 경로를 연결해줘야 합니다. 다음 코드를 todo/urls.py 또는 프로젝트의 urls.py에 추가해 주세요.

from django.urls import path
from . import views

urlpatterns = [
    path('todos/', views.todo_list, name='todo_list'),
]

이제 브라우저에서 http://127.0.0.1:8000/todos/ 주소로 접속하면, 뷰 함수가 동작하며 템플릿에 데이터를 전달하게 됩니다.

🧠 실전 활용 팁

  • .order_by('-created_at')으로 최신 항목부터 정렬할 수 있어요.
  • .filter()를 활용하면 특정 조건만 골라볼 수도 있어요.

지금까지 배운 내용은 Django의 데이터 흐름에서 가장 중요한 부분 중 하나입니다. 뷰 함수는 데이터와 템플릿 사이의 다리 역할을 하며, 이를 제대로 이해해야 Django를 진짜 잘 다룰 수 있게 돼요.

6. 템플릿에서 목록 출력 및 브라우저 확인 🖥️

이제 마지막 단계예요! 뷰에서 전달한 QuerySet 데이터를 템플릿 파일에 출력해보겠습니다. 이렇게 하면 우리가 만든 모델 데이터를 브라우저에서 직접 볼 수 있게 되죠.

📄 템플릿 파일 생성하기

우선 앱 폴더 안에 templates 폴더를 만들고, 그 안에 todo 폴더를 생성한 후 list.html이라는 파일을 만듭니다. 예시 경로는 다음과 같아요:

todo/
 ├── templates/
 │    └── todo/
 │         └── list.html

그리고 list.html에는 아래처럼 작성해 주세요.



  
  Todo 목록

할 일 목록
    {% for item in todos %}
        {{ item.title }}

        {{ item.content }}

        {{ item.created_at }}
      
    {% empty %}아직 등록된 항목이 없습니다.
    {% endfor %}
  


Django의 템플릿 언어인 {% for %}{{ }}를 활용해서 데이터를 반복 출력하고 있어요. 실제 데이터가 없을 경우엔 {% empty %} 블럭이 작동합니다.

📌 설정 점검 리스트

  • settings.pyTEMPLATES 설정에 'APP_DIRS': True가 되어 있는지 확인
  • 앱 이름이 INSTALLED_APPS에 포함되어 있어야 함

🌐 브라우저에서 확인해보기

이제 python manage.py runserver 명령으로 개발 서버를 실행하고, 브라우저에서 http://127.0.0.1:8000/todos/ 주소로 접속해보세요.

등록한 데이터가 목록으로 출력된다면... 성공입니다! 🎉

이 과정을 통해 데이터베이스 모델 생성 → Admin 등록 및 입력 → View에서 데이터 조회 → Template에서 출력까지 전체 웹 애플리케이션 흐름을 완성해본 셈이에요.

마무리하며 🧩

지금까지 우리는 Django에서 모델을 생성하고 데이터를 출력하는 전 과정을 순차적으로 경험해 봤습니다. 처음에는 복잡하게 느껴질 수 있지만, 한번 흐름을 타고 나면 의외로 논리적이고 직관적인 걸 느끼셨을 거예요.

전체 흐름을 요약하면 다음과 같습니다:

  1. 모델 정의 (models.py)
  2. 마이그레이션으로 DB에 반영
  3. Admin에 모델 등록 및 슈퍼유저 생성
  4. 뷰 함수에서 QuerySet으로 데이터 조회
  5. 템플릿에 데이터 넘기고 브라우저에 출력

이제 여러분은 Django 웹 개발에서 가장 기본이 되는 MVT(Model-View-Template) 패턴의 흐름을 완전히 이해한 셈입니다. 앞으로 더 복잡한 프로젝트를 다룰 때도 이 흐름은 그대로 유지되며, 이 토대를 기반으로 기능만 점점 확장되니까요.

다음 글에서는 모델 간 관계 설정(ForeignKey 등)과 리스트 정렬, 필터링 등의 고급 QuerySet 사용법까지 이어서 다뤄볼 예정이에요. 계속해서 함께 성장해봐요! 😊

반응형
반응형

Django 데이터베이스 연동과 ORM 이해

Django 프로젝트에서 데이터를 저장하고 꺼내 쓰는 게 어렵게 느껴지시나요?
ORM과 관리자 페이지의 마법을 경험해보세요!

 

 

안녕하세요, 여러분! 😊

웹 애플리케이션을 만들다 보면 사용자 데이터를 저장하거나, 게시글을 등록하고 수정하는 기능이 꼭 필요하죠.

이럴 때 가장 중요한 게 바로 데이터베이스 연동입니다.

이번 포스팅에서는 Django에서 가장 기본적으로 사용하는 SQLite 설정부터, 데이터를 자유자재로 다룰 수 있게 해주는 ORM(Object-Relational Mapping)의 개념과 사용법을 살펴볼 거예요.

또한 Django의 강력한 무기 중 하나인 Admin 페이지를 통해 데이터를 관리하는 방법까지 같이 다루겠습니다.

처음엔 조금 생소할 수 있지만, 하나씩 따라오다 보면 데이터베이스가 생각보다 친숙하게 느껴질 거예요. 😊

자, 그럼 본격적으로 시작해볼까요?

 

1. SQLite 설정과 마이그레이션 개념 🧱

Django는 기본적으로 SQLite라는 가볍고 사용하기 쉬운 데이터베이스를 기본으로 제공합니다.

설치할 것도 없고, 별도의 서버 없이 바로 사용 가능하다는 점에서 개발자들 특히 초보자에게 아주 좋은 선택이죠.

📂 settings.py에서 데이터베이스 확인하기

settings.py 파일을 열면 아래와 같이 DATABASES 설정이 이미 되어 있을 거예요.

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

 

이게 바로 SQLite를 사용하는 기본 설정입니다.

별다른 작업 없이 바로 데이터베이스 기능을 쓸 수 있게 도와주는 설정이죠.

🔧 마이그레이션이란 무엇인가요?

Django에서 모델을 만들었다고 해서 바로 DB에 반영되는 건 아니에요.

모델의 변경사항을 데이터베이스에 적용하려면 마이그레이션(Migration) 작업을 해야 합니다.

이 과정을 쉽게 설명하면 이래요:

  • 모델을 만들면 그걸 반영할 SQL 코드가 자동으로 생성됨 → makemigrations
  • 생성된 SQL 코드를 실제 DB에 반영 → migrate

터미널에서 아래 명령어를 실행해보세요.

python manage.py makemigrations
python manage.py migrate

이제 모델에 정의한 구조대로 테이블이 데이터베이스에 생성됩니다. 짠! 너무 어렵지 않죠?

📋 요약 테이블

개념 설명
SQLite Django 기본 데이터베이스로, 가볍고 별도 설치가 필요 없음
makemigrations 모델 변경 사항을 기반으로 마이그레이션 파일 생성
migrate 생성된 마이그레이션을 실제 데이터베이스에 적용

 

2. Django 모델 정의 방법과 필드 종류 📝

웹 서비스에서 정보를 저장하고 관리하려면 모델(Model)을 정의해야 합니다.

Django에서는 이 모델이 곧 데이터베이스 테이블과 1:1로 매칭돼요.

각 모델은 Python 클래스 형태로 정의되며, 클래스의 속성 하나하나가 데이터베이스의 컬럼이 됩니다.

📌 모델 클래스 예시

from django.db import models

class Post(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

위 예시는 Post라는 게시글 모델입니다.

title, content, created_at이라는 세 개의 필드를 가지고 있고, 각각 문자열, 긴 텍스트, 생성 시간 정보를 저장해요.

🔍 주요 필드(Field) 종류 알아보기

필드 이름 설명
CharField 짧은 문자열 저장. max_length 필수 지정
TextField 긴 텍스트 저장 (제한 없음)
IntegerField 정수 값 저장
DateTimeField 날짜/시간 저장. auto_now_add 또는 auto_now로 자동 설정 가능
BooleanField True/False 값 저장

💡 유용한 모델 설정 옵션들

  • verbose_name: 필드의 이름을 관리자 페이지에서 보기 쉽게 설정
  • default: 기본값 지정 가능
  • null, blank: 비워도 되는지 여부 설정

모델은 단순히 테이블을 정의하는 걸 넘어서, Django 전반의 데이터 흐름을 담당해요.

앞으로의 기능 구현에서도 계속 활용되니, 지금 확실하게 익혀두는 걸 추천드립니다!

 

 

3. ORM과 QuerySet으로 데이터 다루기 ⚙️

Django에서는 ORM(Object-Relational Mapping) 기능을 통해 Python 코드만으로도 데이터베이스를 자유롭게 다룰 수 있습니다.

즉, 복잡한 SQL을 몰라도 객체 지향적으로 데이터를 삽입하고 수정하며 삭제할 수 있어요.

이게 진짜... 너무 편해요.

🛠️ 기본적인 데이터 조작 예시

# 객체 생성
post = Post(title="첫 글", content="장고 너무 재밌다!")
post.save()

# 모든 데이터 조회
Post.objects.all()

# 조건에 맞는 데이터 조회
Post.objects.filter(title__contains="첫")

# 하나만 가져오기
Post.objects.get(id=1)

# 데이터 수정
post = Post.objects.get(id=1)
post.title = "수정된 제목"
post.save()

# 데이터 삭제
post.delete()

보시다시피 .save(), .filter(), .get(), .delete() 같은 메서드만 알면 데이터를 마음대로 다룰 수 있어요.

쿼리셋(QuerySet)을 이용하면 복잡한 조건도 체이닝해서 쉽게 만들 수 있고요.

🔍 자주 쓰는 QuerySet 메서드 정리

메서드 설명
all() 모든 객체를 조회
filter() 조건에 맞는 객체만 조회
get() 특정 조건에 맞는 하나의 객체 조회 (없거나 둘 이상이면 오류)
exclude() 특정 조건을 제외한 객체 조회
order_by() 정렬 기준 지정

이런 메서드들을 조합하면, 꽤 복잡한 데이터 필터링도 몇 줄 안 되는 코드로 깔끔하게 해결할 수 있어요.

그러니까요, 진짜 ORM은 신세계예요.

⚠️ 주의할 점!

  • get()은 여러 개의 결과가 있거나 없을 때 예외 발생! 항상 try/except로 감싸는 게 좋아요.
  • save()를 안 하면 DB에 반영되지 않아요. 반드시 저장해 주세요!

Django ORM은 입문자에게도 매우 직관적으로 다가오는 도구입니다.

복잡한 SQL 없이도 실무 수준의 데이터 처리가 가능하다는 건 정말 큰 장점이에요.

 

 

4. Django Admin 사이트 활용법 🛠️

Django를 처음 접하면 누구나 놀라는 기능이 있어요.

바로 Admin 사이트입니다!

개발자가 만든 모델을 관리자 페이지에서 바로 추가, 수정, 삭제할 수 있는 인터페이스가 기본 제공된다는 건... 솔직히 말해 사기급이에요.

🔐 관리자 계정 만들기

먼저 관리자 페이지를 사용하려면 슈퍼유저(superuser)를 생성해야 합니다.

터미널에서 아래 명령어를 입력해보세요.

python manage.py createsuperuser

이후 사용자명, 이메일, 비밀번호를 입력하면 관리자 계정이 생성됩니다.

서버를 실행하고 http://localhost:8000/admin 으로 접속해보세요!

🧩 모델 등록하기

관리자 페이지에서 직접 데이터를 관리하려면 모델을 admin에 등록해야 합니다.

해당 앱의 admin.py 파일을 열고 아래처럼 작성해보세요.

from django.contrib import admin
from .models import Post

admin.site.register(Post)

이제 관리자 페이지에 "Post" 메뉴가 생겨요.

여기서 데이터를 추가하거나 삭제할 수 있는 폼 UI가 자동으로 생성됩니다.

🎨 관리자 화면 커스터마이징

관리자 페이지의 기본 UI도 커스터마이징이 가능합니다.

예를 들어 제목, 생성일만 리스트에 보이게 하려면 아래처럼 코드를 수정하면 돼요.

class PostAdmin(admin.ModelAdmin):
    list_display = ('title', 'created_at')

admin.site.register(Post, PostAdmin)

이런 식으로 list_filter, search_fields, readonly_fields 등 다양한 옵션을 지정해 관리 페이지를 내가 원하는 대로 꾸밀 수 있어요.

🧾 관리자 페이지 요약

기능 설명
createsuperuser 관리자 계정 생성
register() 모델을 admin 사이트에 등록
list_display 목록에서 보여줄 필드 지정

이처럼 Django의 Admin 사이트는 개발자가 데이터 관리 페이지를 손쉽게 만들 수 있도록 도와줍니다.

특히 초기에 빠르게 MVP를 만들거나 내부 관리 도구가 필요할 때 아주 유용해요.

 

 

5. 예고: 모델 간 관계 설정 개념 🔗

지금까지는 하나의 모델만을 기준으로 데이터를 다뤘어요.

하지만 현실 세계의 데이터는 대부분 서로 관계를 맺고 있죠.

예를 들어, 사용자(User)가 여러 개의 게시글(Post)을 작성하거나, 하나의 카테고리(Category)가 여러 개의 상품(Product)을 포함하는 구조 말이에요.

🔄 다양한 관계(Relation)의 형태

  • 1:1 관계 (OneToOneField) – 예: 사용자와 프로필
  • 1:N 관계 (ForeignKey) – 예: 사용자와 게시글
  • N:N 관계 (ManyToManyField) – 예: 사용자와 그룹

이런 관계를 정의하려면 Django 모델에서 ForeignKey, OneToOneField, ManyToManyField 같은 필드를 사용합니다.

 

다음 블로그 글에서는 이렇게 모델 간 관계를 정의하고 이를 활용하는 방법을 심도 있게 다룰 예정이에요.

예를 들어 게시글(Post)에 작성자(User)를 연결하거나, 하나의 글에 여러 개의 댓글(Comment)을 연결하는 구조를 만드는 실전 예제를 보여드릴게요.

 

복잡한 데이터 구조도 Django에서는 간단하고 우아하게 정의할 수 있다는 사실, 꼭 다음 편에서 확인해보세요!

 

 

6. 마무리 정리 및 다음 글 안내 📌

이번 포스팅에서는 Django에서 데이터를 다루기 위해 꼭 알아야 할 데이터베이스 설정, 모델 정의, ORM 사용법, 그리고 Admin 사이트 활용까지 폭넓게 살펴봤습니다.

처음에는 생소할 수 있는 개념들이지만, 직접 따라 해보면서 실습해보면 어느 순간 "아, 이제 좀 알겠다!" 하는 순간이 분명 찾아올 거예요.

데이터를 설계하고 관리하는 과정은 앞으로 더 다양한 기능들을 구현할 때 아주 중요한 기반이 됩니다.

그리고 다음 글에서는 드디어 모델 간 관계 설정에 대해 본격적으로 들어갑니다.

ForeignKey를 이용해 사용자와 게시글을 연결하고, 댓글을 추가해보는 등 조금 더 현실적인 예제를 다룰 예정이에요.

 

🔥 이제 여러분은 Django 데이터 모델링의 첫 단계를 마스터했습니다.

      다음 단계에서는 훨씬 더 유기적이고 확장성 있는 데이터 구조를 함께 만들어봅시다!

반응형
반응형

첫 Django 앱 생성과 간단한 페이지 구현

"Hello, Django!" 한 줄로 시작되는 웹 개발의 첫 걸음,
지금부터 함께 만들어 볼까요?

 

 

안녕하세요, 개발자 여러분!

오늘은 Django 프로젝트를 시작하고, 여러분만의 첫 웹 페이지를 만들어보는 시간을 가져보려 해요.

Django 프레임워크를 설치하고 프로젝트를 구성해본 분이라면, 이제 본격적으로 실습에 들어가볼 때죠.

페이지를 하나 만들고 웹 브라우저에서 “Hello, Django!”라는 메시지를 확인할 수 있는 과정을 따라가면서, 뷰(View), 템플릿(Template), URLconf의 연계 방식도 자연스럽게 익혀볼 수 있어요.

처음엔 복잡하게 느껴질 수 있지만, 한 걸음씩 차근차근 따라가면 어렵지 않답니다.

특히 이번 글에서는 실습 위주로 접근할 예정이라 초보자분들도 큰 부담 없이 이해하실 수 있을 거예요.

 

1. 새로운 앱 생성과 프로젝트에 등록하기 🧱

이제 본격적으로 Django 프로젝트 안에 첫 번째 앱을 만들어볼 시간입니다.

Django에서는 웹 애플리케이션의 기능 단위를 "앱(app)"이라는 구조로 나누어 구성합니다.

예를 들어, 게시판 기능, 회원 관리 기능, 블로그 기능 등이 각각 독립된 앱으로 만들어질 수 있어요.

📌 앱 생성 명령어

python manage.py startapp pages

 

이렇게 입력하면 pages라는 이름의 디렉토리가 생성되고, 그 안에 Django 앱의 기본 구조가 자동으로 세팅됩니다.

🛠 프로젝트에 앱 등록하기

앱을 생성했으면 Django 프로젝트에 해당 앱을 등록해줘야 해요.

settings.py 파일을 열고, INSTALLED_APPS 리스트에 아래와 같이 추가해줍니다.

INSTALLED_APPS = [
    ...
    'pages',
]

 

이렇게 하면 pages 앱이 프로젝트에 포함되어 Django가 이 앱을 인식하게 됩니다.

앞으로 이 앱 안에서 뷰, URL, 템플릿 등을 구성해나갈 거예요.

🧾 요약 정리

  • python manage.py startapp pages 명령어로 앱 생성
  • settings.pyINSTALLED_APPS에 'pages' 추가

 

이제 다음 단계로 넘어가서, 우리가 만든 pages 앱 안에 첫 번째 뷰 함수를 작성해보겠습니다.

 

 

2. 간단한 뷰 함수 작성하기 🧠

이제 우리가 만든 pages 앱 안에서 실제로 페이지를 보여주는 뷰 함수(view function)를 작성해보겠습니다. 이 뷰 함수는 사용자의 요청을 받아 HTML 페이지를 반환하는 역할을 하죠.

🔧 views.py 파일 수정

우선 pages/views.py 파일을 열고 아래와 같이 간단한 함수를 만들어주세요.

from django.shortcuts import render

def home(request):
    return render(request, 'home.html')

 

이 함수는 request 객체를 받아 home.html이라는 템플릿 파일을 렌더링(render)해서 클라이언트에게 반환합니다.

아직 템플릿 파일은 없지만, 이건 다음 단계에서 만들어볼 거예요!

💡 render 함수란?

Django에서 render() 함수는 템플릿 시스템과 뷰를 연결하는 역할을 합니다.

내부적으로 Template 객체를 로드하고, 전달받은 데이터를 해당 템플릿에 렌더링한 뒤 HTML을 반환하죠.

아주 자주 쓰이기 때문에 꼭 익혀두세요!

🧾 요약 정리

  • views.py에서 home() 뷰 함수 생성
  • render(request, 'home.html')로 템플릿 반환

다음 단계에서는 home.html 템플릿 파일을 실제로 만들어볼 거예요.

우리의 "Hello, Django!" 메시지를 웹에 띄워볼 준비 되셨죠?

 

 

3. 템플릿 디렉터리 및 HTML 파일 생성 ✨

이제 우리의 뷰 함수가 불러올 home.html 파일을 만들어야 할 차례입니다.

Django에서는 HTML 파일을 templates 폴더에 보관하는 게 일반적이에요.

📁 템플릿 디렉터리 구조 만들기

앱 디렉터리(pages/) 안에 templates/pages 폴더를 생성하세요.

이 구조는 Django가 템플릿을 앱과 연결된 이름으로 찾을 수 있도록 도와줍니다.

pages/
├── templates/
│   └── pages/
│       └── home.html

 

이제 home.html 파일을 만들어 아래와 같은 내용을 넣어보세요.

<!-- pages/templates/pages/home.html -->
<!DOCTYPE html>
<html lang="ko">
<head>
  <meta charset="UTF-8">
  <title>My First Django Page</title>
</head>
<body>
  <h1>Hello, Django!</h1>
</body>
</html>

 

이 HTML 파일은 우리가 웹 브라우저에서 확인하게 될 페이지입니다.

정말 간단하죠? 하지만 여기서 중요한 건 템플릿 파일이 뷰 함수에서 지정한 경로와 정확히 일치해야 한다는 점이에요.

💡 템플릿 폴더 명명 규칙 팁

  • 앱 이름과 동일한 하위 폴더를 templates 내부에 생성해야 충돌 없이 사용할 수 있어요.
  • ex) pages 앱이면 templates/pages/home.html 경로로 생성

이제 이 템플릿을 웹 페이지로 띄울 수 있도록 URLconf 설정을 해보러 갈까요?

 

 

4. URLconf 설정으로 뷰 연결하기 🔗

뷰와 템플릿을 만들었지만, 아직 웹 브라우저에서 페이지를 열 수 없어요.

왜냐하면 URLconf를 설정하지 않았기 때문이죠.

Django에서는 urls.py를 통해 요청 URL과 뷰를 연결해줍니다.

📌 앱 수준 URLconf 만들기

pages 앱 디렉터리 안에 urls.py 파일을 새로 만들어 아래와 같이 작성해 주세요.

# pages/urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('', views.home, name='home'),
]

 

이제 앱 수준의 URLconf는 준비가 끝났고, 이를 프로젝트 루트 urls.py에 연결만 하면 됩니다.

🔧 프로젝트 루트 urls.py 연결

프로젝트 디렉터리에 있는 config/urls.py 파일을 열어 아래와 같이 include를 이용해 pages 앱을 연결합니다.

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('pages.urls')),
]

 

이제 http://localhost:8000/ 경로로 접속하면 pages.views.home 뷰가 실행되고, home.html이 브라우저에 출력됩니다.

🧾 요약 정리

  • pages/urls.py에 뷰 함수 연결
  • config/urls.py에서 include('pages.urls')로 연결 완료

URL 설정까지 끝났다면, 다음 단계는 드디어! 웹 브라우저에서 페이지를 확인해보는 일입니다.

화면에 'Hello, Django!'가 뜨는 그 짜릿한 순간을 함께 느껴볼까요?

 

 

5. 웹 브라우저에서 결과 확인하기 🌐

자, 모든 준비는 끝났습니다!

이제 로컬 개발 서버를 실행해서 우리가 만든 페이지가 잘 나오는지 확인해보는 일만 남았어요.

이 순간이 바로 Django 개발의 가장 첫 성취감이 느껴지는 타이밍이죠 😊

▶ 서버 실행

python manage.py runserver

 

명령어를 실행하면 다음과 같이 서버가 8000번 포트에서 실행되었다는 메시지를 볼 수 있습니다:

Watching for file changes with StatReloader
Performing system checks...

System check identified no issues (0 silenced).
April 17, 2025 - 22:05:00
Django version 4.x.x, using settings 'config.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

 

이제 브라우저를 열고 주소창에 http://127.0.0.1:8000 또는 http://localhost:8000 를 입력해 보세요!

🎉 확인 결과

화면에 커다란 "Hello, Django!" 문구가 보였다면... 성공입니다! 🎉

지금 여러분은 Django 기반 웹페이지를 세상에 (아직은 로컬이지만) 처음 띄운 셈이에요.

💡 오류가 발생했을 때는?

  • 템플릿 경로가 잘못되었을 가능성 확인
  • URLconf 연결 상태 점검

이제 HTML이 정상 출력되는 걸 확인했으니,

다음 단계에서는 템플릿을 조금 더 효율적으로 관리하는 방법—바로 템플릿 상속 기법을 소개해드릴게요.

 

 

6. 베이스 템플릿 작성과 템플릿 상속 🏗️

Django 템플릿 시스템은 반복되는 HTML 코드 구조를 효율적으로 관리할 수 있도록 템플릿 상속 기능을 제공합니다. 이번 단계에서는 베이스 템플릿을 만들어서 여러 페이지에서 공통으로 사용할 수 있게 구성해볼 거예요.

📁 베이스 템플릿 만들기

pages/templates/ 디렉토리 하위에 base.html이라는 파일을 만들고 다음과 같이 작성합니다.

<!-- pages/templates/base.html -->
<!DOCTYPE html>
<html lang="ko">
<head>
  <meta charset="UTF-8">
  <title>{% block title %}Django App{% endblock %}</title>
</head>
<body>
  <header>
    <h1>🎈 Django App</h1>
  </header>
  
  <main>
    {% block content %}{% endblock %}
  </main>
  
  <footer>
    <p>&copy; 2025 My Django</p>
  </footer>
</body>
</html>

 

이제 home.html 파일을 다음과 같이 수정해서 base.html을 상속받도록 할게요.

<!-- pages/templates/pages/home.html -->
{% extends 'base.html' %}

{% block title %}홈{% endblock %}

{% block content %}
  <h2>Hello, Django!</h2>
  <p>이 페이지는 템플릿 상속을 사용하여 만들어졌습니다.</p>
{% endblock %}

 

이제 home.htmlbase.html의 구조를 그대로 따라가면서 본문 내용만 바꿀 수 있어요.

앞으로 다른 페이지도 이 구조를 재사용하면 유지보수가 훨씬 편해지겠죠?

💡 템플릿 상속의 장점

  • 여러 페이지에서 반복되는 코드(HTML 구조)를 한 곳에서 관리 가능
  • 유지보수 시 공통 구조 수정이 한 파일로 해결
  • 템플릿 블록으로 내용만 손쉽게 커스터마이징

이제 하나의 틀만 만들어두면 여러 페이지를 손쉽게 만들 수 있어요.

뭔가 웹사이트 같아지지 않았나요? 😄

마무리 ✨

오늘은 Django에서 첫 번째 앱 생성부터 웹 페이지 출력까지의 흐름을 따라가봤습니다.

하나하나 따라가면서 뷰, 템플릿, URL 설정의 연결 구조를 눈으로 확인하고, 직접 HTML로 결과를 출력해보셨을 거예요.

단순한 "Hello, Django!"지만, 처음으로 화면에 결과를 띄웠다는 경험은 아주 중요한 첫걸음입니다.

더 나아가 base.html을 통해 템플릿 상속도 경험해보면서, 앞으로 프로젝트가 커졌을 때 어떻게 효율적으로 유지보수를 할 수 있을지에 대한 감도 잡으셨을 거라 믿어요.

 

다음 시간에는 이 구조를 기반으로 동적인 데이터를 다루는 방법, 폼 처리, 모델 연동 등 더 본격적인 웹 애플리케이션 기능 구현으로 넘어가볼게요.

지금처럼 한 걸음씩 차근차근 따라오신다면 Django가 훨씬 더 친숙하게 느껴질 거예요 😊

📌 오늘 배운 핵심 요약

  • startapp 명령어로 앱 생성 및 프로젝트에 등록
  • 뷰 함수 render()로 템플릿 반환
  • 템플릿 폴더 및 HTML 작성
  • URLconf를 통한 뷰 연결
  • 템플릿 상속으로 공통 레이아웃 구성

 

처음 웹 서비스를 만들어보는 분들께 정말 꼭 필요한 흐름이었죠?

다음 포스트에서는 이 앱에 사용자 입력을 처리할 수 있는 폼(form) 기능을 추가해볼 예정입니다.

기대해 주세요!

반응형
반응형

Django 앱 구조와 URL·뷰·템플릿 완전 정복

“Django에서 프로젝트랑 앱은 도대체 뭐가 다르죠?”
처음 Django를 배우는 분들이 가장 많이 묻는 질문 중 하나예요.
사실 이 부분만 확실히 잡아도 개발이 훨씬 쉬워져요.

 

 

안녕하세요, 여러분!

오늘은 Django 웹 개발에서 가장 중요한 구조적인 개념들을 하나하나 짚어보는 시간을 가져보려고 해요.

특히 초보자 분들이 헷갈려하기 쉬운 "프로젝트 vs 앱", URL과 뷰 연결 방식, 템플릿 활용법, 정적 파일 처리 방법까지!

MVT 아키텍처의 흐름을 시각적으로, 예제를 통해 명확하게 설명드릴게요.

이 포스팅을 마치고 나면 여러분은 Django의 기본 골격을 스스로 이해하고 구성할 수 있을 거예요.

 

1. 프로젝트 vs 앱: Django의 구조 이해하기 🏗️

Django를 시작하면 가장 먼저 접하게 되는 용어가 바로 프로젝트(project)앱(app)이에요.

이 두 개념을 명확히 구분하는 것이 굉장히 중요해요.

왜냐하면 우리가 만드는 서비스가 커질수록 구조를 제대로 이해하지 않으면 코드가 뒤엉켜버리기 때문이죠.

📌 프로젝트(Project)란?

프로젝트는 Django에서 웹 애플리케이션 전체를 포함하는 최상위 공간이에요.

예를 들어, 여러분이 ‘블로그 사이트’를 만든다고 하면, 그 전체 웹사이트가 하나의 프로젝트가 되는 거예요.

settings.py, urls.py, wsgi.py, asgi.py 같은 핵심 설정 파일들이 이 프로젝트 안에 포함되어 있죠.

📦 앱(App)이란?

앱은 프로젝트 내부에 포함되어 하나의 독립적인 기능 단위를 담당하는 컴포넌트입니다.

예를 들어

게시판 기능은 하나의 앱으로, 사용자 인증 기능은 또 다른 앱으로 구성할 수 있어요.

이처럼 앱은 재사용성과 모듈화를 위해 만들어지는 거죠.

📁 기본 폴더 구조 예시

myproject/
├── manage.py
├── myproject/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   ├── asgi.py
│   └── wsgi.py
└── blog/         ← 앱
    ├── admin.py
    ├── apps.py
    ├── models.py
    ├── views.py
    ├── urls.py
    └── templates/

✅ 비교 정리

구분 프로젝트(Project) 앱(App)
의미 전체 웹사이트의 틀 기능별 모듈
역할 설정 및 라우팅 총괄 뷰, 모델, 템플릿 포함
재사용성 낮음 높음

🎯 요약 포인트

  • 프로젝트는 설정의 중심, 앱은 기능의 중심!
  • 하나의 프로젝트에 여러 개의 앱을 넣는 구조가 Django의 핵심.

 

 

2. MVT 아키텍처 요청-응답 흐름 🔁

Django는 MVT 아키텍처라는 구조를 기반으로 동작합니다.

여기서 MVT는 Model - View - Template의 약자예요.

많은 사람들이 헷갈리는 부분이 바로 'View'인데요.

다른 프레임워크에서의 View와는 조금 다른 개념이랍니다.

🔄 MVT의 구성요소

  • Model
  • : 데이터베이스와 연동되는 계층으로, 데이터 구조와 저장 로직을 담당해요.
  • View
  • : URL 요청을 받아 처리하고, 어떤 데이터를 보여줄지 결정하는 비즈니스 로직 처리 담당이에요.
  • Template
  • : 사용자에게 보여지는 HTML 화면을 담당하는 프론트엔드 계층입니다.

📡 요청-응답 흐름

MVT 구조는 사용자의 요청이 서버에 도달했을 때 어떤 방식으로 응답이 이루어지는지를 순서대로 처리해요.

아래는 그 흐름을 간단히 도식화한 거예요.

1. 사용자가 웹 브라우저에서 특정 URL 요청
2. Django가 URLconf에서 해당 URL 패턴 탐색
3. 매칭되는 View 함수 호출
4. View 함수가 Model을 통해 데이터 처리
5. View가 Template에 데이터 전달
6. Template이 HTML 생성하여 사용자에게 응답 반환

🌐 예시 흐름: 블로그 글 목록 보기

사용자가 /posts/ 주소로 접속하면 Django는 urls.py에서 이 URL과 매칭되는 View 함수를 찾습니다.

그 View는 Post 모델에서 데이터를 조회하고, 이를 템플릿(post_list.html)에 전달하여 HTML 페이지를 렌더링한 후 응답으로 전송해요.

🔁 한 문장 요약

URL → View → Model → Template → 사용자 응답 이 흐름을 이해하는 것이 Django 개발의 핵심이에요!

 

 

3. URLconf와 View 함수 연결 방법 🔗

Django에서 사용자가 어떤 페이지를 요청하면,

그 요청은 URLconf(URL configuration)라는 설정 파일을 통해 해당 View 함수와 연결됩니다.

이 과정을 이해하면, 웹사이트의 구조를 자유자재로 설계할 수 있어요!

📁 urls.py의 역할

urls.py는 URL 패턴을 정의하는 파일이에요.

이 파일을 통해 "이 URL 요청이 들어오면, 어떤 View 함수로 전달할지"를 결정하죠.

마치 웹사이트의 길 안내를 해주는 네비게이션 같은 존재예요.

📨 View 함수는 무슨 역할을 하나요?

View 함수는 요청을 받아 필요한 데이터를 조회하거나 가공한 후, 적절한 응답(HTML, JSON 등)을 만들어 반환합니다.

비즈니스 로직의 중심이며, 종종 모델과 템플릿 사이의 가교 역할도 해요.

🔧 간단한 연결 예제

# app/views.py
from django.http import HttpResponse

def home(request):
    return HttpResponse("Hello, Django!")

# app/urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('', views.home, name='home'),
]

위 코드에서 사용자가 / 경로로 접속하면 home 함수가 실행되고, 그 결과로 "Hello, Django!"가 출력되는 구조예요.

🔁 프로젝트 전역 URLconf 연동

앱 단위로 작성된 urls.py는 프로젝트의 메인 urls.py에서 include()를 통해 불러와야 작동합니다.

예를 들어:

# project/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('app.urls')),  # 앱의 URLconf 포함
]

📚 URL, View 연결 요약

  • View는 함수를 통해 사용자 요청을 처리하고 응답을 만들어냅니다.
  • urls.py는 "이 요청은 이 View로!" 라는 연결고리 역할을 합니다.
  • 프로젝트와 앱의 urls.py를 함께 구성해야 Django가 전체 요청을 인식해요.

 

 

4. 템플릿 엔진 사용 방법과 정적 파일(Static files) 처리 개념 🧩

Django의 매력 중 하나는 강력한 템플릿 엔진과 정적 파일 시스템이에요.

이 두 가지를 잘 활용하면, 백엔드 개발자가 프론트엔드 영역까지 손쉽게 다룰 수 있어요.

HTML 코드에 Python 데이터도 넣을 수 있고, CSS, JS, 이미지도 깔끔하게 관리할 수 있죠.

🧠 템플릿 엔진이란?

Django의 템플릿 엔진은 HTML 문서 안에 Python 데이터와 로직을 삽입할 수 있도록 도와주는 도구입니다.

변수 출력, 조건문, 반복문 등을 통해 동적인 HTML 페이지를 생성할 수 있어요.

📝 템플릿 사용 예시

<h1>Hello, {{ username }}!</h1>
{% if is_admin %}
<p>관리자 권한이 있습니다.</p>
{% else %}
<p>일반 사용자입니다.</p>
{% endif %}

이처럼 {{ 변수 }}를 통해 데이터를 출력하고, {% if %} ... {% endif %} 문법으로 조건을 제어할 수 있어요.

📁 정적 파일 처리(Static files)

정적 파일(static files)은 HTML과 함께 로드되는 CSS, JS, 이미지 파일을 말해요.

Django는 이러한 파일들을 별도로 관리하기 위한 시스템을 제공해요.

📦 폴더 구조 예시

myproject/
├── static/
│   ├── css/
│   │   └── style.css
│   └── js/
│       └── script.js
├── templates/
│   └── index.html

🔗 템플릿에서 정적 파일 사용하기

{% load static %}

{% load static %}을 선언하고, {% static '경로' %}를 사용하면 정적 파일을 안전하게 불러올 수 있어요.

이렇게 하면 개발 환경과 운영 환경 모두에서 호환성이 좋아집니다.

🧷 정리 한 줄 요약

템플릿은 Django가 HTML에 데이터를 주입할 수 있게 해주는 똑똑한 도구이고, 정적 파일 처리는 스타일과 동작을 책임지는 프론트엔드 리소스를 관리하는 방법이에요!

 

 

5. 템플릿 상속 개념 소개 🧱

여러 페이지를 가진 웹사이트를 만들다 보면, 모든 페이지에 공통적으로 들어가는 부분이 있죠?

예를 들면, 상단 메뉴, 푸터, 로고 같은 것들요.

이런 부분을 매번 복사해서 붙여넣는 건 비효율적이고, 나중에 유지보수도 어렵습니다.

Django는 이런 문제를 템플릿 상속이라는 기능으로 아주 깔끔하게 해결해줘요.

🏛️ 베이스 템플릿이란?

base.html 또는 layout.html이라고 불리는 이 베이스 템플릿은 공통 레이아웃을 정의해두는 템플릿이에요.

각 개별 페이지는 이 템플릿을 {% extends %}로 확장하고, {% block %} 태그를 통해 특정 부분만 바꿔서 사용할 수 있어요.

📐 베이스 템플릿 예제


  {% block title %}My Site{% endblock %}
  

My Website Header
  
    {% block content %}{% endblock %}
  © 2025 MySite
  


위 템플릿은 타이틀과 본문 부분을 block으로 정의해뒀고, 다른 템플릿에서 이걸 상속받아 사용하게 돼요.

🔁 상속받는 하위 템플릿 예시 --------------------------------------------------------------------------


{% extends "base.html" %}

{% block title %}홈 페이지{% endblock %}

{% block content %}

<p data-ke-size="size16">환영합니다! 여기는 홈입니다.</p>

{% endblock %}

home.htmlbase.html을 확장하면서 제목과 콘텐츠 영역만 바꿔 끼워넣은 거예요.

이렇게 하면 전체 구조는 유지하면서 내용만 바꾸는 게 가능해요!

💡 템플릿 상속의 장점

  • 중복 코드 제거로 생산성 향상 💼
  • 레이아웃 일관성 유지로 유지보수 용이 🔧
  • 각 페이지 별 핵심 콘텐츠에만 집중할 수 있음 🎯

📌 요약 정리

템플릿 상속은 기본 골격은 하나로 통일하고, 내용만 바꾸는 웹 페이지 관리 방식이에요.

규모가 커질수록 이 방식의 장점은 더 강력해집니다!

 

 

6. 예제와 함께 전체 흐름 복습하기 📚

지금까지 배운 내용을 하나의 흐름으로 묶어서 복습해볼까요?

Django에서 하나의 웹 페이지가 동작하는 과정을 예제 기반으로 정리해보면, 머릿속이 훨씬 깔끔해질 거예요!

📝 목표: 사용자 이름을 입력받아 인사하는 페이지 만들기

이 예제에서는 사용자가 /hello/홍길동처럼 이름을 URL로 전달하면, 그 이름을 화면에 보여주는 간단한 인사 페이지를 만들어요.

① URLconf 설정

# app/urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('hello//', views.hello_user, name='hello'),
]

② View 함수 작성

# app/views.py
from django.shortcuts import render

def hello_user(request, username):
    context = {'username': username}
    return render(request, 'hello.html', context)

③ 템플릿 작성 

{% extends "base.html" %}

{% block title %}인사하기{% endblock %}

{% block content %}

{{ username }}님, 반가워요! 👋

{% endblock %}

💡 전체 동작 흐름 요약

  1. 1. 사용자가 /hello/홍길동을 입력
  2. 2. urls.py에서 해당 URL을 찾아 hello_user 뷰로 연결
  3. 3. 뷰 함수에서 받은 이름을 템플릿에 전달
  4. 4. hello.htmlbase.html을 상속받아 출력
  5. 5. 사용자 화면에 환영 메시지 출력 완료!

🎯 마무리 요약

Django는 URL, View, Template의 구조를 이해하고 적절히 연결하는 것만으로도 강력한 웹 페이지를 쉽게 만들 수 있어요.

오늘 배운 흐름을 반복해 익혀두면 어떤 웹 페이지든 자신 있게 구현할 수 있답니다!

 

 

마무리 🏁

여기까지 따라오시느라 정말 고생 많으셨어요!

오늘은 Django의 웹 개발에서 가장 핵심이 되는 구조들, 즉 프로젝트와 앱의 개념, MVT 아키텍처 흐름, URL과 View 연결, 템플릿과 정적 파일 처리, 템플릿 상속까지 모두 다뤄봤습니다.

이 글에서 다룬 내용은 Django 개발의 기반이 되는 핵심이기 때문에 꼭 숙지하시는 걸 추천드려요.

처음엔 복잡해 보일 수 있지만, 한두 번 실습해보면 금방 손에 익는 구조랍니다.

 

앞으로 게시판, 블로그, 쇼핑몰, 포트폴리오 사이트 등을 만들 때도 오늘 배운 흐름을 그대로 적용할 수 있어요. 혹시 다음 단계로 어디서부터 손대야 할지 막막하신가요? 그렇다면 지금 만든 구조에 간단한 게시글 모델과 폼을 추가해보세요. 점점 더 강력한 기능을 얹어갈 수 있을 거예요.

 

다음 글에서는 Django 모델(Model)과 데이터베이스 ORM에 대해 다뤄볼 예정이니 기대해주세요!

“코드는 직접 짜보는 만큼 이해도는 깊어진다.”

반응형
반응형

개발환경 구축과 Django 프로젝트 시작

처음 Django를 설치하고 프로젝트를 시작할 때,
어디서부터 손대야 할지 막막하셨죠?
이 글 하나면 OK! 🔧
반응형

 

안녕하세요,  여러분! 😄

오늘은 여러분이 Django라는 강력한 웹 프레임워크를 사용해 첫 프로젝트를 시작할 수 있도록 개발환경을 세팅하고, Django 프로젝트를 만드는 첫걸음을 함께 해보려 해요.

이 글은 단순히 코드를 나열하는 튜토리얼이 아니라, 왜 그렇게 해야 하는지까지도 친절히 설명할 테니, 걱정은 접어두시고 커피 한잔과 함께 따라와 주세요! ☕

특히 Python 기초만 알고 있어도 충분히 이해할 수 있게 구성되어 있어, Django 입문에 완벽한 가이드가 될 거예요.

 

1. 가상환경이란? 왜 필요한가요?

처음 Django를 공부하거나 개발 프로젝트를 시작할 때 가장 먼저 듣게 되는 단어가 바로 가상환경(virtual environment)입니다. 근데, 왜 굳이 이런 걸 써야 할까요? 🤔

그냥 파이썬 깔고 바로 쓰면 되는 거 아닌가요?

사실, 간단한 스크립트나 학습용 코드에는 크게 상관이 없을 수 있어요.

하지만 프로젝트마다 사용하는 라이브러리 버전이 다르거나 충돌이 발생하는 상황에서는 이야기가 달라집니다.

예를 들어, 프로젝트 A에서는 Django 3.2를, 프로젝트 B에서는 Django 4.0을 쓴다고 해보죠.

이런 경우, 시스템 전체에 Django를 설치했다면 서로 충돌이 날 수밖에 없어요.

💡 가상환경을 쓰면 좋은 점!

  • 프로젝트마다 독립된 환경 제공 → 충돌 방지
  • 불필요한 시스템 오염 방지 → 유지보수 용이
  • 협업 시, 환경 일관성 유지 → 배포도 쉬움

📌 실제로 어떻게 동작하나요?

가상환경은 단순히 파이썬 인터프리터와 라이브러리 디렉토리를 복사해서 독립된 환경으로 만들어 주는 거예요.

우리가 만든 가상환경 안에서는 시스템에 설치된 다른 라이브러리와 상관없이, 내가 원하는 버전만 설치해서 쓸 수 있죠.

🧪 예시로 알아보는 상황

항목 가상환경 없음 가상환경 사용
Django 버전 시스템 전역에 하나만 존재 프로젝트마다 다르게 가능
라이브러리 충돌 다른 프로젝트 영향 가능 서로 독립적
배포 환경 패키지 충돌로 실패할 수 있음 확실한 환경 재현 가능

가상환경에 대해 좀더 알아보실 분들은 아래 포스트를 참고해주세요

https://firstcoding.net/74

 

파이썬 가상환경(venv, virtualenv)으로 프로젝트 환경을 깔끔하게 관리하는 법

파이썬 가상환경(venv, virtualenv)으로 프로젝트 환경을 깔끔하게 관리하는 법프로젝트마다 패키지 버전이 달라서 자꾸 충돌난다면? 파이썬 가상환경으로 환경관리를 시작해보세요! 🧪  안녕하

firstcoding.net

 

 

이제 감이 오셨죠? 😀

다음 글에서는 가상환경을 직접 만들고 Django를 설치하는 실습을 해볼게요!

명령어 한 줄 한 줄, 왜 그런지까지 설명하며 알려드릴게요.

바로 다음 단계에서 만나죠!

 

 

2. 가상환경 만들기와 Django 설치하기

이번에는 실제로 가상환경을 만들고, Django를 설치하는 과정을 하나씩 해보겠습니다.

윈도우 사용자 기준으로 설명하지만, macOS나 리눅스도 거의 동일해요.

다만 경로나 명령어가 조금 다를 수 있으니 참고만 해주세요.

⚙️ Step-by-step: 가상환경 만들기

  1. 프로젝트를 위한 디렉토리를 만듭니다. 
  2. CLI 환경에서 아래 코드 실행
  3. mkdir my_django_project cd my_django_project
  4. 가상환경을 생성합니다. venv는 파이썬 기본 제공 가상환경 툴입니다.
    python -m venv venv
  5. 가상환경을 활성화합니다.
    • Windows: venv\Scripts\activate
    • macOS/Linux: source venv/bin/activate

🎉 명령어를 실행한 후, 프롬프트 앞에 (venv)가 붙으면 성공적으로 가상환경에 들어온 것입니다!



🌐 Django 설치하기

이제 본격적으로 Django를 설치해볼게요.

pip는 Python의 패키지 관리자로, Django도 pip를 통해 간단히 설치할 수 있어요.

pip install django

 


설치가 완료되면 다음과 같이 버전을 확인할 수 있습니다.

django-admin --version

💡 Tip: requirements.txt 만들기

앞으로 협업하거나 서버에 배포할 땐 requirements.txt 파일이 꼭 필요해요.

지금 설치된 패키지를 저장해두면 나중에 pip install -r requirements.txt 명령으로 똑같이 설치할 수 있죠!

pip freeze > requirements.txt

 

📎 설치 요약 정리

단계 명령어
1. 디렉토리 생성 mkdir my_django_project
2. 가상환경 생성 python -m venv venv
3. 가상환경 활성화 venv\Scripts\activate
4. Django 설치 pip install django

이제 준비는 끝났습니다. 🎉

다음 단계에서는 Django 프로젝트를 생성하고 실행하는 법을 배워볼 거예요.

준비되셨죠? 바로 다음 STEP에서 만나봐요!

 

 

3. Django 프로젝트 생성과 폴더 구조 이해

이제 드디어 본격적인 Django 프로젝트를 시작할 차례입니다!

가상환경도 만들고 Django도 설치했으니, 첫 프로젝트를 만들어볼까요?

이 단계에서는 django-admin이라는 명령어를 사용해서 새로운 프로젝트를 생성합니다.

🚀 django-admin startproject 명령어 사용하기

django-admin startproject config .

 

위 명령어에서 config는 프로젝트 이름입니다.

원하는 이름으로 바꿔도 돼요! 뒤에 붙은 .(점)은 “현재 디렉토리에 바로 생성하겠다”는 뜻인데, 폴더 구조가 한 번 더 중첩되는 걸 막아줘요.

💡 점(.)을 안 붙이면 어떻게 되나요?

config/config/처럼 디렉토리가 두 겹이 돼서 조금 헷갈릴 수 있어요.

.을 붙여주면 루트 디렉토리에 필요한 파일만 깔끔하게 생성됩니다!

📂 Django 프로젝트 기본 구조 설명

명령어를 실행하면 다음과 같은 디렉토리 구조가 만들어집니다.

my_django_project/
├── manage.py
├── config/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   ├── asgi.py
│   └── wsgi.py
파일/디렉토리 설명
manage.py Django 명령어를 실행할 때 사용하는 메인 스크립트 (예: runserver, migrate)
settings.py 프로젝트의 모든 설정 정보 (DB, 앱 등록, 경로 등)
urls.py URL 라우팅을 담당하는 곳, 어떤 URL로 어떤 기능을 실행할지 지정
wsgi.py / asgi.py 웹 서버와 연결하기 위한 인터페이스 스크립트 (배포 시 사용)

VSCode 실행



아직은 생소한 파일이 많을 수 있지만, 앞으로 차근차근 다룰 거니까 걱정 마세요. 😊

이제 다음 단계에서는 manage.py를 이용해 Django 개발 서버를 실행하고, 환영 페이지를 띄워보는 실습을 진행할게요!


4. 개발 서버 실행하고 환영 페이지 보기

지금까지 프로젝트를 생성했고, 폴더 구조도 확인했죠?

이제 실제로 Django가 어떻게 동작하는지, 개발 서버를 실행해보고 웹 브라우저에서 결과를 확인해볼 시간이에요.

딱 10초만에 Django의 기본 환영 페이지를 만나볼 수 있어요! 🌈

▶️ 개발 서버 실행하기

가상환경이 활성화되어 있고, Django 프로젝트 디렉토리 안에 있다면 아래 명령어만 입력하면 됩니다.

python manage.py runserver

 

✅ 명령어 실행 후, 아래와 같은 메시지가 보이면 성공적으로 서버가 실행된 거예요!

Watching for file changes with StatReloader
Performing system checks...

System check identified no issues (0 silenced).
April 17, 2025 - 22:30:02
Django version 4.x, using settings 'config.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

🌐 Django 환영 페이지 보기

웹 브라우저를 열고 주소창에 다음을 입력해보세요:

http://127.0.0.1:8000/

 

 

이 주소는 로컬호스트(localhost), 즉 여러분의 컴퓨터를 의미합니다.

성공적으로 실행되었다면, Django의 멋진 초록색 체크 표시가 있는 환영 화면을 보게 될 거예요! 🎉

🤔 에러가 난다면?

  • 가상환경이 활성화되지 않았을 수 있어요.
  • venv\Scripts\activate 또는 source venv/bin/activate를 다시 확인!
  • manage.py 파일이 있는 디렉토리에서 실행했는지 확인!

📌 Django 개발 서버의 특징

항목 설명
자동 감지 코드 수정 시 서버 재시작 없이 자동 반영
기본 포트 8000번 포트를 사용 (--port 옵션으로 변경 가능)
개발 전용 운영 환경에서는 사용 ❌ (보안상 취약함)

어떠셨나요?

처음으로 브라우저에서 Django 프로젝트가 돌아가는 걸 확인하면 꽤 뿌듯하실 거예요!

다음은 프로젝트 내부 파일들 — 특히 settings.py, urls.py — 들의 역할을 자세히 살펴보겠습니다. 🛠️

 

 

5. 프로젝트 주요 파일 설명 (settings.py, urls.py 등)

Django 프로젝트를 만들고 서버도 돌려봤는데, 폴더 안에 있는 파일들... 솔직히 처음 보면 좀 겁나죠? 😅

settings.py, urls.py, wsgi.py, asgi.py 등등… 이름은 많은데 도대체 다 무슨 역할을 하는 걸까요?

이번에는 이 중요한 파일들을 하나하나 살펴보면서, Django가 어떤 구조로 움직이는지 확실히 이해해보는 시간을 가질게요. 🧠

⚙️ settings.py – 프로젝트 설정의 본부

Django에서 가장 중요한 파일 중 하나예요.

이름 그대로 프로젝트 전반의 설정을 담당합니다.

데이터베이스 연결부터 앱 등록, 보안 설정까지 모두 여기에 있어요.

  • INSTALLED_APPS – 사용할 앱 목록 (예: admin, auth 등)
  • MIDDLEWARE – 요청/응답을 가로채는 중간 처리기 리스트
  • DATABASES – 어떤 DB를 쓸지 (기본은 SQLite)
  • STATIC_URL – 정적 파일(CSS, JS 등)의 기본 경로

🌐 urls.py – URL과 View를 연결해주는 라우터

클라이언트가 어떤 URL로 접근했을 때 어떤 페이지나 기능을 보여줄지를 설정하는 파일입니다.

즉, URL ↔ View 함수의 연결고리 역할을 하죠.

from django.contrib import admin
from django.urls import path

urlpatterns = [
    path('admin/', admin.site.urls),
]

 

위 코드는 /admin/ 경로로 접속하면 Django의 관리자 페이지로 이동하도록 설정한 예입니다.
앞으로 여기에 직접 만든 뷰 함수들을 추가해가며 프로젝트를 확장할 거예요!

🌐 wsgi.py & asgi.py – 서버와 Django의 연결고리

이 두 파일은 웹 서버(Gunicorn, Daphne 등)가 Django 앱과 통신할 수 있도록 해주는 인터페이스 스크립트입니다. 단, 개발 단계에서는 거의 사용할 일이 없어요. 프로젝트를 실제 배포할 때 사용된다고 기억만 해두시면 충분합니다!

파일 설명
wsgi.py 동기 방식 배포용 (예: Gunicorn)
asgi.py 비동기 웹 서버용 (예: Daphne, Uvicorn)


이처럼 Django 프로젝트의 각 파일은 서로 역할을 나누어 구조적으로 움직입니다.

각각을 이해하고 있으면 앞으로 앱 개발 시 어떤 파일을 수정해야 하는지, 어디를 먼저 살펴봐야 하는지 훨씬 수월해질 거예요.

 

 

6. 자주 묻는 질문 및 초보자 팁 ✨

처음 Django를 접할 때 헷갈리는 부분이 정말 많죠?

특히 에러 메시지가 뜨면 ‘뭐가 뭔지 모르겠어!’ 하고 당황하기 쉬워요.

그래서 이 섹션에서는 실제 수강생이나 독자들이 자주 물어봤던 질문과, 제가 직접 겪으며 깨달았던 꿀팁들을 정리해드릴게요.

“아 이거 나만 몰랐던 거 아니었구나!” 싶은 순간이 올지도 몰라요. 😅

❓ 자주 묻는 질문 (FAQ)

  1. Q. 가상환경은 프로젝트마다 꼭 만들어야 하나요?
    네, 무조건 만드는 걸 추천드려요!
    그래야 라이브러리 버전 충돌을 막을 수 있고, 협업 시에도 동일한 환경을 유지할 수 있어요.
  2. Q. pip install이 안 될 때는 어떻게 해야 하나요?
    인터넷 연결 상태를 먼저 확인해보세요.
    그리고 python -m pip install --upgrade pip로 pip 버전을 최신으로 유지하는 것도 중요해요.
  3. Q. runserver 했는데 접속이 안 돼요!
    가상환경이 활성화되어 있는지, manage.py가 있는 디렉토리에서 명령어를 실행했는지 다시 확인해보세요.
  4. Q. Django 버전은 어떤 게 좋아요?
    최신 버전을 사용하는 것이 보안과 성능 면에서 좋아요.
    다만, 공식 문서에서 권장하는 LTS 버전을 사용하는 것도 안정적인 선택이에요.

💡 실수 방지용 초보자 꿀팁!

  • 매번 서버를 끄고 켤 필요 없어요!
    Django는 코드 변경 사항을 자동으로 감지해서 반영해줘요.
    서버만 켜두면 실시간으로 확인할 수 있어요.
  • settings.py는 손댈 땐 복사본부터!
    혹시 오류 나면 되돌릴 수 있도록 settings.py 파일을 백업해두세요.
  • 에러 메시지를 잘 읽자!
    Django는 에러 메시지를 정말 친절하게 써줘요.
    천천히 읽으면 해결 실마리가 보입니다.
  • pyenv나 poetry 등 도구도 나중에 배워보자!
    파이썬 프로젝트를 더 잘 관리할 수 있는 도구들이에요.
    초보 땐 몰라도 되지만, 나중엔 꼭 도움이 될 거예요.

처음부터 완벽할 필요는 없어요. 저도 Django 처음 시작할 땐 runserver 한 줄 치는 것도 긴장했거든요. 😅

중요한 건 에러를 두려워하지 않고 천천히 쌓아가는 태도입니다.

이제 여러분도 Django의 첫 문을 열었으니, 계속해서 앱을 만들고 실습하면서 자신감을 키워보세요!

 

 

Django 입문의 첫 발걸음을 축하합니다! 🎉

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

처음에는 생소했던 가상환경 생성부터 Django 설치, 프로젝트 구조 이해, 그리고 서버 실행까지 모두 직접 해보셨습니다.

처음 접하면 낯설고 어색했던 단계들이 이제는 조금은 익숙해졌을 거예요.

Django는 강력하고 유연한 웹 프레임워크입니다.

아직은 단순한 “Hello Django” 단계지만, 앞으로 여러분은 이걸 기반으로 블로그, 게시판, 로그인 시스템, API 서버까지 만들 수 있어요.

이제 정말 웹 개발자가 되는 길이 시작된 것이죠.

 

다음 단계로는 앱 생성 및 라우팅, 데이터베이스 모델 만들기, CRUD 구현, 템플릿 시스템 등으로 나아가면 됩니다.

이 블로그 시리즈에서도 그 모든 과정들을 차근차근 함께 걸어갈 예정이니, 즐겁게 따라와 주세요!

🌱 작은 성공이 쌓이면, 어느새 성장합니다

오늘처럼 하나씩 직접 따라해보고 작은 성취감을 느껴보세요.

그게 쌓이면 진짜 실력이 됩니다.

개발은 재능보다 꾸준함이 더 중요한 분야랍니다. 저도 그랬고요. 😉

 

여러분의 Django 첫 걸음을 응원합니다! 🚀

다음 글에서는 앱 생성과 URL 연결로 한 걸음 더 나아가볼게요.

반응형
반응형

웹 개발 기초와 Django 프레임워크 개요

여러분, Python만 알면 웹 사이트도 뚝딱 만들 수 있다면 믿으시겠어요?
Django는 그걸 가능하게 해주는 도구예요!

 

 

안녕하세요, 여러분~! 😊
혹시 "웹 개발"이라는 말만 들어도 벌써 머리가 복잡해지는 분 계신가요? 저도 처음엔 그랬어요.

HTML, CSS, JavaScript, 서버, 데이터베이스... 어디서부터 시작해야 할지 막막했거든요.

그래서 이 시리즈에서는 여러분이 편안하게 웹 개발의 기초를 익힐 수 있도록, 정말 친절하고 쉽게!

Django라는 프레임워크를 중심으로 하나하나 알려드릴 거예요.

오늘은 그 첫 걸음으로, 웹 개발이 무엇인지, HTTP란 무엇이며, Django는 어떤 역할을 하는지, 그리고 개발을 시작하기 위한 로컬 환경은 어떻게 준비하는지 이야기해볼게요.

마치 요리를 시작하기 전 재료부터 차근히 준비하듯, 개발도 준비가 반이니까요!

 

1. HTTP란 무엇인가요? 🌐

웹 개발을 제대로 이해하려면 가장 먼저 HTTP라는 용어부터 알아야 해요.

HyperText Transfer Protocol의 약자인 HTTP는 인터넷에서 정보를 주고받을 때 사용하는 기본 규칙이에요.

쉽게 말해, 웹 브라우저와 서버가 대화할 때 사용하는 언어죠.

우리가 웹 브라우저에 주소를 입력하면 HTTP 요청(Request)이 발생하고, 서버는 거기에 맞는 HTTP 응답(Response)을 보냅니다.

예를 들어,

여러분이 https://www.google.com에 접속하면 브라우저는 "이 주소에 해당하는 내용을 주세요!"라고 요청하고, 서버는 "여기 있어요!" 하면서 응답을 보내는 거예요.

📋 주요 HTTP 메서드 정리

메서드 설명 예시
GET 데이터를 조회할 때 사용 /articles
POST 새로운 데이터를 생성할 때 사용 /articles (글 작성)
PUT 기존 데이터를 수정할 때 사용 /articles/3 (3번 글 수정)
DELETE 데이터를 삭제할 때 사용 /articles/3 (3번 글 삭제)
  • 클라이언트 = 웹 브라우저, 서버 = 정보를 제공하는 곳
  • HTTP는 이 둘의 소통을 위한 ‘공용 언어’예요
  • 다양한 메서드를 통해 어떤 ‘행동’을 할지 서버에 알려줘요

정리하자면, HTTP는 웹 개발의 기본 중의 기본입니다.

이 개념을 확실히 이해하고 있어야 웹 프레임워크가 하는 일을 자연스럽게 받아들일 수 있어요.

다음 섹션에서는 웹 프레임워크가 도대체 무슨 일을 해주는지도 살펴볼게요.

 

 

2. 웹 프레임워크의 개념과 역할 🧱

웹 개발을 처음 접하는 분들은 "웹 프레임워크"라는 말이 좀 낯설게 느껴질 수 있어요.

웹 프레임워크란 쉽게 말해서, 웹사이트를 만들기 위한 재료와 조리도구가 모두 포함된 요리 세트라고 생각하면 됩니다.

우리가 만약 웹 프레임워크 없이 개발한다면, 요청 처리, URL 연결, 폼 검증, 데이터 저장, 보안, 세션 등 모든 걸 직접 다 만들어야 해요.

마치 라면도 면부터 직접 뽑고, 스프도 만들고, 그릇도 빚는 느낌... 😵‍💫 하지만 프레임워크를 사용하면 이런 반복적인 작업들을 자동화하고 간편화해줍니다.

💡 웹 프레임워크가 하는 일

  • 사용자가 입력한 URL을 어떤 기능과 연결할지 결정해요 (라우팅)
  • 사용자의 입력값을 안전하게 처리해줘요 (폼 검증, 보안 필터)
  • 데이터베이스와 연결해서 정보를 읽고 쓰게 해줘요
  • 사용자가 보는 웹 페이지도 만들어 줘요 (템플릿 렌더링)

✔ 왜 웹 프레임워크를 써야 할까?

  1. 복잡한 웹 기능을 빠르고 쉽게 구현할 수 있어서
  2. 보안, 성능, 유지보수 등 전문가들이 설계한 기능을 그대로 활용할 수 있어서
  3. 문서화와 커뮤니티가 잘 되어 있어서 문제 해결이 쉬워요

이제 왜 웹 프레임워크가 중요한지 감이 오시죠?

Django는 그런 프레임워크 중에서도 아주 강력하고, 쉬우며, 실무에서도 많이 쓰이는 대표적인 녀석이에요. 다음 장에서는 Django가 왜 그렇게 많은 사랑을 받는지 그 매력을 살펴보죠!

 

 

3. Django의 특징과 장점 ✨

Django(장고)는 Python 기반의 웹 프레임워크예요.

"The web framework for perfectionists with deadlines"라는 슬로건처럼, 빠르고 깔끔한 개발을 원하는 사람들에게 안성맞춤이에요. 🧑‍💻

처음 접하면 다소 방대해 보일 수 있지만, 알고 보면 개발자의 귀차니즘을 가장 잘 이해하는 프레임워크랍니다!

💎 Django의 대표적인 장점

특징 설명
빠른 개발 폼, 인증, 관리자 페이지 등 대부분 기능을 기본 제공
보안 XSS, CSRF, SQL Injection 등 웹 보안 이슈에 강함
확장성 다양한 앱을 쉽게 붙여서 서비스 확장이 가능함
관리자 기능 자동으로 생성되는 관리자 페이지는 신의 한 수!

📌 이런 분들에게 강력 추천!

  • 프론트엔드보다 백엔드가 더 궁금한 분
  • 서비스 MVP를 빠르게 만들어보고 싶은 스타트업 창업자
  • Python을 배워봤고 이제 웹을 해보고 싶은 분!

Django는 국내외 수많은 웹사이트에서 실전(!)으로 쓰이고 있어요.

여러분도 곧 Django로 진짜 작동하는 웹 서비스를 만들 수 있을 거예요.

이제 Django가 어떻게 구조화되어 있는지, 그 핵심인 MVT 패턴으로 넘어가 볼까요?

 

 

4. Django의 MVT 아키텍처 이해 🧩

웹 프레임워크마다 나름의 아키텍처 구조를 갖고 있어요.

Django에서는 MVT(Model-View-Template) 패턴을 사용합니다.

이건 흔히 들어본 MVC(Model-View-Controller)와 비슷하면서도 Django만의 방식이 녹아 있어요.

📚 MVT 구성요소 한눈에 보기

구성요소 역할 설명
Model 데이터 구조 설계 DB 테이블과 직접 연결, 데이터 읽고 쓰기 담당
View 비즈니스 로직 요청 처리, 어떤 데이터를 보여줄지 결정
Template 사용자에게 보여질 UI HTML로 데이터를 표현하는 데 사용

📌 Django에서의 흐름 정리

  1. 사용자가 웹사이트에 어떤 요청을 보냅니다 (예: 게시글 목록 보기).
  2. View가 그 요청을 받고, 필요한 데이터를 Model에서 가져옵니다.
  3. 가져온 데이터를 Template에 넘겨서 예쁘게 보여줍니다.

이렇게 역할을 명확히 나눔으로써 개발자는 로직만, 디자이너는 UI만 집중할 수 있어요.

협업도 편하고, 유지보수도 쉬워지는 Django의 큰 장점 중 하나랍니다!

이제 Django의 구조까지 살펴봤으니, 실전 준비를 해볼 차례죠.

다음 파트에서는 여러분의 PC에서 Django 개발을 시작할 수 있도록 Windows 개발 환경을 셋업하는 방법을 알아봅니다!

 

 

5. Windows에서 개발환경 준비하기 🛠️

본격적으로 Django를 사용해서 웹 개발을 하려면, 먼저 내 PC에 개발환경부터 갖춰야 해요.

이번 파트에서는 Windows 기반의 로컬 개발환경을 단계별로 구성하는 법을 알려드릴게요.

🔧 Step-by-Step 개발환경 설정 가이드

  1. Python 설치
  2. 가상환경(venv) 설정
  3. 필수 패키지 설치 (pip 이용)
  4. Django 설치 및 프로젝트 시작

1. Python 설치하기 🐍

공식 사이트에 들어가서 Python 최신 버전을 다운로드하고 설치합니다.

설치 시 "Add Python to PATH" 옵션을 꼭 체크해야 해요!

 

Download Python

The official home of the Python Programming Language

www.python.org


파이썬 설치 관련 내용 확인
https://firstcoding.net/54

 

파이썬 개발환경 구축 완벽 가이드 (2025 최신판)

파이썬 개발환경 구축 완벽 가이드 (2025 최신판)처음 파이썬을 배우려는데, 설치부터 뭐가 이렇게 많아?VSCode? 파이참? 뭐가 뭔지 모르겠다면 이 글 하나면 끝!  안녕하세요 😊요즘 AI 열풍 덕분

firstcoding.net

 

2. 가상환경 만들기 💡

가상환경은 프로젝트마다 독립적인 패키지 공간을 만들어줘요. 아래 명령어를 실행해볼게요.

python -m venv venv
venv\Scripts\activate

성공하면 명령 프롬프트에 (venv)가 붙어요.

 

가상환경에 대해 좀더 알아보실 분들은 아래 포스트를 참고해주세요

https://firstcoding.net/74

 

파이썬 가상환경(venv, virtualenv)으로 프로젝트 환경을 깔끔하게 관리하는 법

파이썬 가상환경(venv, virtualenv)으로 프로젝트 환경을 깔끔하게 관리하는 법프로젝트마다 패키지 버전이 달라서 자꾸 충돌난다면? 파이썬 가상환경으로 환경관리를 시작해보세요! 🧪  안녕하

firstcoding.net

 

이제 여기서 Django를 설치하면 됩니다!

3. Django 설치 및 프로젝트 시작 🚀

pip install django
django-admin startproject mysite
cd mysite
python manage.py runserver

위 명령어까지 완료했다면 127.0.0.1:8000 주소로 접속해보세요!

Django 환영 페이지가 나온다면 성공이에요! 🎉

여러분은 지금 Django 웹 개발의 첫 발을 디디셨어요.

앞으로 이 환경에서 앱을 만들고, 데이터베이스를 연결하고, 멋진 서비스를 구현하게 될 거예요!

 

 

6. Python 설치와 가상환경 설정 ⚙️

앞선 STEP에서 간단하게 개발환경을 구성해봤다면, 이번에는 조금 더 자세히 Python 설치와 가상환경 설정에 대해 알아보겠습니다. 특히 여러 프로젝트를 동시에 개발하려면 가상환경을 잘 활용하는 습관이 정말 중요해요.

📌 Python 설치 팁

  • 설치 중 반드시 “Add Python to PATH” 체크!
  • 버전 충돌 방지를 위해 최신 버전 사용 권장

설치 후 명령 프롬프트에서 다음 명령어로 확인해볼 수 있어요.

python --version
pip --version

🌱 가상환경(venv) 개념 다시 보기

가상환경은 말 그대로 프로젝트마다 독립적인 Python 공간이에요.

예를 들어,

블로그 웹사이트에선 Django 4.2 버전을 쓰고, 쇼핑몰 웹사이트에선 3.2 버전을 쓸 수도 있어요.

이런 걸 가능하게 해주는 게 바로 가상환경입니다.

✔ 가상환경 관리 명령어

명령어 설명
python -m venv venv 가상환경 생성
venv\Scripts\activate 가상환경 활성화 (Windows)
deactivate 가상환경 종료

📎 실전 꿀팁

  • Visual Studio Code를 쓰면 터미널에서 바로 가상환경을 인식해줘요!
  • requirements.txt 파일을 만들어 두면 나중에 패키지 설치가 훨씬 쉬워요.

지금까지 Python 설치와 가상환경 설정에 대해 배워봤어요.

이제 여러분은 Django 개발을 위한 기초 체력을 모두 갖췄다고 볼 수 있죠.

그럼 이제, 이 여정을 마무리하면서 여러분이 앞으로 어떻게 시작하면 좋을지 정리해볼게요!

 

 

🧩 이제 Django 세계로 출발해볼까요?

여기까지 따라오셨다면 정말 수고 많으셨어요!

HTTP의 기본 구조부터 Django의 매력, MVT 패턴, 그리고 개발환경 설정까지 웹 개발을 시작하는 데 꼭 필요한 기초를 차근차근 다졌습니다. 👏

이제 여러분은 개발자 노트북을 열고, Django로 나만의 웹 서비스를 만들 준비가 된 셈이죠.

"아직 잘 모르겠어요..."라는 생각이 드시더라도 괜찮아요.

개발은 해보면서 익히는 것이니까요.

 

다음 글부터는 Django 프로젝트를 하나씩 만들어보면서 실습 중심으로 배워볼 거예요.

"왜 이렇게 동작하지?"라는 의문이 들면 이 글로 다시 돌아와 주세요.

기초는 늘 탄탄하게, 다시 반복할수록 더 잘 보이거든요 😉

 

그럼 우리 다음 글에서는 Django 프로젝트를 직접 만드는 방법으로 이어가 볼게요.

같이 실습하면서 진짜 서비스를 만들 준비되셨죠? 🎯

반응형
반응형

파이썬 FastAPI 실전 프로젝트 구현 (2) – 기능 보완 및 마무리

여러분, 프로젝트 마무리할 때 뭔가 찝찝하게 끝낸 적 있으시죠?
이번에는 FastAPI로 만든 API를 제대로 다듬고,
진짜 ‘완성된’ 느낌을 만들어봐요!

 

 

안녕하세요, 개발자 여러분 😊

드디어 FastAPI 실전 프로젝트의 마지막 단계에 도달했습니다.

앞서 API를 설계하고 기본적인 CRUD 기능을 구현했지만, 사실 프로젝트가 ‘완성됐다’고 말하기 위해서는 몇 가지 마무리 작업이 꼭 필요하죠.

예를 들어 빠진 기능을 채우거나, 리팩토링을 통해 코드 품질을 끌어올리고, 전체 테스트를 통해 문제가 없는지 꼼꼼히 검증하는 과정 말이에요.

이번 글에서는 Update/Delete API 구현, 리팩토링, 테스트 마무리, 추가 기능 구현까지 포함해서, 진짜 실전에 가까운 프로젝트 완성 과정을 함께 해볼 거예요.

이제 진짜 개발자 포트폴리오에 올릴 수 있는 API를 만들어볼 준비되셨나요? 😎 그럼 시작해볼게요!

 

1. CRUD 기능 보완: Update/Delete 엔드포인트 구현 🛠️

1.1 글(Post) 및 할일(Todo) 수정 API 구현

이제 남은 CRUD 기능 중 '수정(Update)' 엔드포인트부터 완성해볼 차례입니다.

블로그 API와 Todo API 모두에 해당하는 기능으로, RESTful한 방식에 따라 PUT 메서드를 사용합니다.

 

FastAPI에서는 @router.put("/posts/{id}") 형식으로 경로를 선언하고, 입력 데이터는 schemas.PostUpdate 같은 Pydantic 모델을 사용해 받습니다.

 

- 수정 대상이 존재하지 않으면 404 Not Found
- 성공 시에는 수정된 객체를 JSON으로 반환
- 인증 기능이 있다면 작성자만 수정 가능하게 조건을 걸 수 있음 (지금은 생략)

예시 코드

@router.put("/posts/{id}")
def update_post(id: int, post_update: PostUpdate, db: Session = Depends(get_db)):
    post = db.query(Post).filter(Post.id == id).first()
    if not post:
        raise HTTPException(status_code=404, detail="Post not found")
    post.title = post_update.title
    post.content = post_update.content
    db.commit()
    db.refresh(post)
    return post

1.2 삭제(Delete) API 구현

삭제 기능은 프로젝트의 정돈을 위해 반드시 필요한 부분이에요.

블로그의 경우 글 삭제, Todo의 경우 할일 삭제가 이에 해당합니다.

완전 삭제 방식으로 구현하되, 보안이나 감사 로그가 필요한 경우에는 Soft Delete 방식도 고민해볼 수 있어요.

예시 코드

@router.delete("/todos/{id}", status_code=204)
def delete_todo(id: int, db: Session = Depends(get_db)):
    todo = db.query(Todo).filter(Todo.id == id).first()
    if not todo:
        raise HTTPException(status_code=404, detail="Todo not found")
    db.delete(todo)
    db.commit()
    return Response(status_code=204)

1.3 마무리 요약

  • PUT 메서드로 수정 API를 추가한다.
  • DELETE 메서드로 삭제 API를 완성한다.
  • 없는 리소스에 접근 시 404 예외 처리를 꼼꼼히 해준다.

이제 CRUD의 4가지 기본 기능이 완성됐습니다.

이 다음은 조금 더 재미있는(?) 추가 기능 구현 시간입니다!

 

 

2. 주제별 추가 기능과 쿼리 개선 🎯

2.1 블로그 API – 사용자별 글 목록 및 검색 기능

블로그 API에선 기본적인 CRUD 외에도, 사용자별 글 목록이나 검색 기능처럼 실전에서 많이 쓰는 기능을 추가해보면 실력이 쑥쑥 자랍니다.

  • GET /users/{user_id}/posts – 특정 유저가 작성한 글만 필터링
  • GET /posts?search=키워드 – 제목/내용에 포함된 키워드로 검색

쿼리 필터 예시

@router.get("/posts")
def list_posts(search: str = None, db: Session = Depends(get_db)):
    query = db.query(Post)
    if search:
        query = query.filter(Post.title.contains(search))
    return query.all()

2.2 Todo API – 완료 여부 필터링 및 정렬

Todo API에선 할 일의 완료 상태우선순위 정렬 기능을 추가하면 사용성이 훨씬 높아져요.

  • GET /todos?completed=true – 완료된 항목만 필터링
  • GET /todos?sort=priority – 우선순위 오름차순 정렬

정렬 필터 예시

@router.get("/todos")
def get_todos(completed: bool = None, sort: str = None, db: Session = Depends(get_db)):
    query = db.query(Todo)
    if completed is not None:
        query = query.filter(Todo.done == completed)
    if sort == "priority":
        query = query.order_by(Todo.priority.asc())
    return query.all()

2.3 마무리 팁 💡

이런 기능은 구현해보면 어렵지 않지만, 실제 API 사용 경험을 엄청나게 향상시켜줍니다.

쿼리 파라미터동적 필터링은 FastAPI와 SQLAlchemy를 익히는 데 정말 좋은 연습이 돼요!

 

꼭 필요한 핵심 기능 외에도 사용자가 편리하게 쓸 수 있는 부가 기능 몇 개만 추가해도, 프로젝트의 깊이가 확 달라진다는 거 잊지 마세요 😉

 

 

3. 코드 리팩토링과 공통 모듈 정리 📦

3.1 중복 로직 정리: get_object_or_404

FastAPI로 프로젝트를 하다 보면, 가장 자주 반복되는 패턴 중 하나가 바로 이거예요.

query.first()로 객체를 가져오고 없으면 HTTPException(404)을 던지는 코드!

매번 반복하지 말고, 다음과 같이 공통 헬퍼 함수로 만들어두면 가독성과 유지보수성이 확 올라갑니다.

def get_object_or_404(query, model_name: str = "Object"):
    obj = query.first()
    if not obj:
        raise HTTPException(status_code=404, detail=f"{model_name} not found")
    return obj

 

이제 이렇게 쓰면 됩니다:

post = get_object_or_404(db.query(Post).filter(Post.id == id), "Post")

3.2 인증/권한 검사 공통화

만약 로그인 인증 기능이 있다면, API마다 인증 정보를 검사하는 코드도 반복됩니다.

FastAPI는 Depends()를 이용해 공통 처리할 수 있어요.

def get_current_user(token: str = Depends(oauth2_scheme)):
    payload = decode_token(token)
    user = db.query(User).filter(User.id == payload["sub"]).first()
    if not user:
        raise HTTPException(status_code=401, detail="Invalid credentials")
    return user

 

라우터에서는 이렇게 간단히 호출하면 되죠:

@router.get("/me/posts")
def my_posts(current_user: User = Depends(get_current_user)):
    return current_user.posts

3.3 Swagger 문서화 향상

Swagger UI를 더 보기 좋게 꾸미고 싶다면, Pydantic 모델에 description 필드를 넣는 게 좋아요.

이게 곧 API 문서가 되거든요.

class PostCreate(BaseModel):
    title: str = Field(..., description="게시글 제목")
    content: str = Field(..., description="게시글 본문")

 

이렇게 하면 Swagger에서 각 필드 설명이 뜨고, 사용자나 동료 개발자에게도 친절한 API가 됩니다. 🧾

3.4 디버그 흔적 제거

그리고 가장 중요한 마무리 습관!

print 같은 디버깅 코드는 모두 제거해주세요.

콘솔에 찍히는 메시지는 실서비스에서 보안 위험이 될 수도 있고, 로그 관리도 어려워지니까요.

  • print() 제거
  • 테스트용 더미 코드 제거

깔끔한 코드는 실력의 증거입니다.

동료도, 미래의 나도 기뻐할 거예요. 😉

 

 

4. Swagger 기반 수동 테스트 🧪

4.1 Swagger UI에서 테스트 시나리오 따라가기

FastAPI의 강력한 무기 중 하나는 바로 자동 생성 API 문서, Swagger UI죠!

개발한 모든 엔드포인트를 웹 UI로 손쉽게 테스트할 수 있다는 점에서, 이건 정말 필수 기능이에요.

 

테스트를 시작할 땐, 가능한 실제 사용자 시나리오 기반으로 순서대로 실행해보는 게 좋아요.

예를 들어:

  1. 1️⃣ 사용자 생성 (POST /users)
  2. 2️⃣ 로그인 (만약 구현했다면)
  3. 3️⃣ 글 or 할일 생성
  4. 4️⃣ 목록 조회
  5. 5️⃣ 글/할일 수정
  6. 6️⃣ 삭제 요청
  7. 7️⃣ 삭제 후 목록 재조회

4.2 예외 상황도 꼭 테스트해보자!

정상 흐름만 테스트하면 부족해요.

진짜 완성도 높은 API는 경계 상황까지 잘 처리하는 경우죠.

 

꼭 체크해야 할 케이스 리스트 ✔️

  • 존재하지 않는 ID로 요청했을 때 → 404 Not Found 잘 반환되는가?
  • 필수 값이 빠진 입력 → 422 Unprocessable Entity 나오는가?
  • 중복된 값 입력 → 에러 메시지가 친절한가?

이런 테스트는 Swagger UI에서 직접 해볼 수도 있지만, Postman이나 curl 같은 도구로 해보는 것도 좋은 연습이에요.

다양한 환경에서 동일한 API가 잘 작동하는지 확인할 수 있거든요.

4.3 마무리하며

직접 테스트해보면서 API 동작을 확인하는 건, 말 그대로 ‘현장감 있는 검증’입니다.

직접 손으로 다뤄보는 만큼, 놓쳤던 버그도 쉽게 발견되죠.

 

이제 우리 프로젝트도 한 단계 성숙해졌네요.

다음은 자동화 테스트로 더 철저하게 완성도를 높이는 시간입니다! 😎

 

 

5. pytest를 활용한 자동화 테스트 🔍

5.1 pytest 기본 구조와 테스트 함수 작성

FastAPI 프로젝트에선 pytest를 사용해 자동화 테스트를 작성하는 게 표준입니다.

기능 하나하나를 수동으로 확인할 수는 없으니, 테스트 코드를 작성해두면 나중에 기능을 수정하거나 리팩토링해도 안정성을 체크할 수 있어요.

예시 테스트 코드

from fastapi.testclient import TestClient
from app.main import app

client = TestClient(app)

def test_create_todo():
    response = client.post("/todos", json={
        "title": "테스트 할일",
        "description": "자동화 테스트용"
    })
    assert response.status_code == 200
    assert response.json()["title"] == "테스트 할일"

 

단순해 보이지만, POST 요청 → 응답 확인 → 예상 결과 비교까지 핵심 흐름이 모두 담겨 있어요.

5.2 테스트 커버리지 넓히기

단일 테스트로는 부족하죠.

아래 항목들을 테스트 목록에 꼭 포함시켜보세요:

  • 목록 조회 (GET) 응답이 올바른지
  • 수정/삭제 요청 시 상태코드 확인
  • 없는 ID로 요청 시 404 테스트

5.3 테스트 실행 및 자동화 팁

터미널에서 다음 명령어를 입력하면 테스트가 실행됩니다.

pytest tests/

 

Tip: GitHub Actions 또는 GitLab CI와 연동하면 커밋할 때마다 자동으로 테스트가 돌아가요.

       이것만 잘해도 실무에선 ‘코드 퀄리티 보장’으로 인정받습니다.

5.4 테스트 작성 못했다면?

사실 시간이 부족하거나 학습이 익숙하지 않다면, 모든 자동화 테스트를 작성하는 건 쉽지 않아요.

그럴 땐 수동 테스트와 로그 확인으로 충분히 대체 가능합니다.

 

하지만 이번 프로젝트가 끝나고 나면 꼭 pytest + FastAPI 조합으로 테스트를 구성해보세요.

다음 프로젝트에서는 코드 품질의 자신감이 달라질 거예요!

 

 

6. 프로젝트 마무리 및 다음 단계 제안 🚀

6.1 FastAPI 프로젝트 완성 축하합니다! 🎉

정말 고생 많으셨어요!

지금까지 FastAPI + SQLAlchemy를 활용해서 REST API를 설계하고, 구현하고, 테스트하고, 마무리까지 해냈습니다.

처음엔 생소하고 어렵게 느껴졌던 코드들도 이제는 익숙하게 다뤘을 거예요. 👏👏👏

6.2 포트폴리오로 남기는 법 💼

  • GitHub에 코드 업로드: 기능별 커밋 기록은 매우 큰 가산점!
  • README.md 작성: 사용 방법, 기능 목록, 설치 방법 포함하면 👍
  • 시연 영상 or 이미지 첨부: 블로그나 유튜브 링크도 함께!

6.3 다음에 도전해볼 것들 ✨

이제 진짜 FastAPI를 익힌 셈이니까요, 다음 단계로 이런 걸 시도해보면 좋습니다:

  • JWT 인증과 OAuth2 로그인 적용 (보안 강화)
  • Docker로 서비스 배포 준비
  • 프론트엔드 연동 (React, Vue 등으로 UI 구현)

6.4 참고 자료 📚

학습을 계속 이어가고 싶다면, 아래 자료들을 추천합니다:

FastAPI는 앞으로도 계속 성장할 프레임워크입니다.

꾸준히 공식 문서를 체크하고, 오픈소스 프로젝트에 기여해보는 것도 추천드려요!

 

 

마무리 🎁

지금까지 우리는 FastAPI를 활용한 실전 프로젝트를 단계별로 구축해왔고, 그 마지막 단계인 기능 보완과 테스트, 리팩토링까지 성공적으로 마무리했습니다.

이 과정을 통해 FastAPI의 기본 구조뿐 아니라 RESTful API 설계, ORM 연동, 예외 처리, 테스트 자동화에 이르기까지 백엔드 개발에서 꼭 필요한 스킬들을 하나씩 익혔어요.

특히 이번 프로젝트는 단순히 작동만 되는 코드가 아닌, 실제 서비스에 가까운 형태로 구현했다는 점에서 큰 의미가 있습니다.

지금까지 작성한 코드들은 포트폴리오로 활용할 수 있을 만큼 구조적이고 완성도가 높아졌습니다.

여기까지 따라오셨다면 정말 큰 박수를 드리고 싶어요. 👏👏👏

 

앞으로는 이 기반 위에 인증, 배포, 프론트엔드 연동 등 더 넓은 분야로 확장해보세요.

그리고 중요한 건 꾸준히 연습하고, 실제 프로젝트에 응용해보는 겁니다.

이제 여러분도 자신 있게 말할 수 있어요.

"FastAPI로 백엔드 개발할 줄 압니다!" 💪

🎯 이 글의 핵심 요약

  • ✅ CRUD 완성: Update/Delete 엔드포인트 구현
  • ✅ 사용자 중심 필터링, 검색 등 추가 기능
  • ✅ 공통 함수 및 인증 구조 리팩토링
  • ✅ Swagger를 통한 수동 테스트
  • ✅ pytest 기반 자동화 테스트 도입
  • ✅ 실무형 프로젝트 구조와 문서화

 

여기서 끝나지 않아요.

지금까지 쌓은 지식을 바탕으로 더 멋진 API, 더 나은 백엔드 시스템을 계속 만들어가시길 바랍니다.

여러분의 여정을 응원합니다! 🚀

반응형
반응형

파이썬 FastAPI 실전 프로젝트 (1) – 블로그 API/Todo API 설계 및 구현 

단순한 예제만으로는 실력이 늘지 않아요.
진짜로 내가 만든 FastAPI 서비스,
지금부터 직접 설계하고 구현해보는 시간입니다!

 

 

안녕하세요 여러분 😊

드디어 지금까지 배운 FastAPI 내용을 바탕으로 직접 프로젝트를 시작할 차례입니다!

이제는 단순한 이론이나 짧은 실습이 아니라, 사용자 관리부터 게시글 또는 할일 등록까지 기능이 갖춰진 나만의 API 서비스를 만들게 될 거예요.

이번 실전 프로젝트는 두 가지 주제 중 하나를 선택해서 진행할 수 있어요:

1) 블로그 API 또는 2) Todo 관리 API.

둘 다 FastAPI + SQLAlchemy를 활용해 RESTful 백엔드 API를 직접 설계하고 구현하는 경험을 하게 됩니다.

각 기능별 CRUD 구현뿐 아니라, 모델 설계, 프로젝트 구조 구성, 예외 처리, 테스트까지 고려한 구조로 만들어볼 거예요.

지금부터 7일차 여정을 함께 출발해볼까요? 🚀

 

1. 최종 프로젝트 개요 및 설계 🧭

여러분, 여기까지 따라오시느라 정말 고생 많으셨어요. 😊

지금까지 FastAPI의 기본적인 사용법, SQLAlchemy 연동, 라우팅, Pydantic 모델링, 예외 처리 등을 하나씩 차근차근 배워오셨죠?

이제는 그 모든 퍼즐을 모아서 직접 하나의 프로젝트로 완성해볼 차례입니다.

1.1 프로젝트 주제와 목표 🎯

이번 프로젝트에서는 두 가지 주제 중 하나를 선택할 수 있어요:

  • 블로그 API: 사용자 인증, 글 작성, 글 목록 조회, 상세 보기, 댓글 작성/삭제, 태그 기능 포함
  • Todo API: 사용자 생성, 할일 CRUD, 우선순위 설정, 완료 상태 필터링 기능 제공

물론 두 프로젝트 모두 공통적으로 사용자 모델, 데이터베이스 연동, CRUD 기능이 핵심이 되며, 선택한 주제에 따라 약간의 기능 차이가 있을 뿐입니다.

1.2 이번 실습의 핵심 목표 🧩

  1. FastAPI의 주요 기능을 실제 API에 적용
  2. SQLAlchemy를 통한 모델 정의와 DB 연동 실습
  3. Pydantic을 활용한 데이터 검증
  4. 기본적인 예외 처리와 테스트 코드 작성
  5. REST API의 CRUD 기능 전반 구현

즉, 이번 실습의 핵심은 단순히 동작하는 코드를 작성하는 것이 아니라, 정리된 구조와 유지보수 가능한 코드를 직접 설계하고 구현하는 것입니다.

실무에서 백엔드를 처음 시작할 때 어떤 흐름으로 개발을 진행해야 하는지, 그 뼈대를 이번 실습을 통해 직접 익히게 될 거예요.

 

이제 다음 단계로 넘어가서, 구체적인 데이터 모델을 어떻게 설계할지 알아보겠습니다.

 

 

2. 데이터 모델 설계 📐

서비스를 만들기 전, 가장 먼저 해야 할 일은 데이터 구조를 어떻게 설계할 것인가입니다.

바로 모델링이죠.

데이터베이스 구조가 깔끔하게 설계되어야 API도 명확하게 작동하고, 유지보수도 수월해집니다.

이번엔 선택한 프로젝트 유형에 따라 각기 다른 모델을 설계하게 됩니다.

2.1 블로그 API 모델 예시 ✍️

블로그 API를 선택한 경우, 보통 다음과 같은 세 가지 모델이 필요해요:

모델 필드 설명
User id, username, email, hashed_password 회원 정보 (비밀번호는 해싱 처리)
Post id, title, content, created_at, author_id 글 제목, 본문, 작성 시간 및 작성자
Comment id, content, created_at, post_id, author_id 댓글 내용과 작성자, 연결된 게시글

여기서 중요한 건 외래키 관계입니다.

Post와 Comment는 모두 User와 연결되고, Comment는 Post에도 연결되죠.

SQLAlchemy에서는 ForeignKeyrelationship으로 이를 구현할 수 있어요.

2.2 Todo API 모델 예시 ✅

Todo 프로젝트는 더 단순합니다. 모델은 아래 두 개만 필요하죠.

모델 필드 설명
User id, username 사용자 이름 (unique 설정 권장)
Todo id, title, description, priority, completed, user_id 할일 제목, 설명, 우선순위, 완료 여부, 사용자

💡 모델 설계 팁

  • 문자열 길이 제한을 String(length)으로 명확하게 지정하세요.
  • nullable=False는 필수 필드에 반드시 지정해줘야 합니다.
  • 고유성이 필요한 필드는 unique=True로 중복 방지!

이제 데이터 모델이 명확하게 정리되었으니,

다음 단계는 실제 프로젝트 디렉토리 구조를 만들고 빈 틀을 잡아보는 것입니다.

프로젝트가 커질수록 구조가 중요해지니까요.

계속해서 다음 단계에서 프로젝트 뼈대를 만들어볼게요!

 

 

3. 프로젝트 구조 뼈대 만들기 🧱

FastAPI 프로젝트를 시작할 때 가장 먼저 해야 할 일은 전체 폴더 구조를 체계적으로 잡는 것이에요.

한 파일 안에 모든 코드를 몰아넣는 방식은 소규모 예제에선 괜찮지만, 프로젝트가 커지면 유지보수가 거의 불가능하죠.

이번 프로젝트에서는 아래와 같은 구조를 기준으로 설계를 시작합니다.

3.1 기본 디렉토리 구조

myapi/
├── main.py               # FastAPI 앱 실행 진입점
├── models.py             # SQLAlchemy ORM 모델 정의
├── schemas.py            # Pydantic 데이터 모델 정의
├── database.py           # DB 설정 (engine, session, get_db)
├── routers/
│   ├── users.py          # 사용자 관련 라우터
│   └── posts.py          # 블로그 글 관련 라우터 (or todos.py)
└── __init__.py           # 패키지 초기화 파일 (선택 사항)

✅ 핵심 원칙은 다음과 같아요:

  • 각 기능을 독립적인 모듈로 구성 → 관심사의 분리(SOC) 원칙 준수
  • DB 관련 코드는 database.py에 모아서 일원화
  • Pydantic 모델은 schemas.py에서 관리하여 API 스키마 명확화

🛠 main.py 기본 틀

from fastapi import FastAPI
from routers import users, posts  # 또는 todos

app = FastAPI()

app.include_router(users.router)
app.include_router(posts.router)

🔌 database.py 기본 구성

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

DATABASE_URL = "sqlite:///./test.db"

engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

Base = declarative_base()

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

이처럼 프로젝트 초기 구조를 잘 설계하면, 나중에 기능을 추가할 때도 훨씬 덜 헤매고 유지보수가 쉬워집니다.

앞으로 posts.py, todos.py, comments.py 등을 기능별로 확장할 수 있도록 유연한 구조로 시작하세요!

 

이제 구조가 준비되었으니, 본격적으로 사용자 기능부터 구현해볼까요?

다음 섹션에서는 사용자 생성과 조회를 구현하면서 실전 코딩을 시작합니다!

 

 

4. 사용자 기능 구현 🔐

프로젝트에서 사용자(User)는 모든 기능의 출발점이에요.

할일이든 게시글이든 결국 ‘누가 작성했는지’가 중요하니까요.

이번 단계에서는 사용자 등록(POST)과 조회(GET) API를 구현합니다.

이 두 기능만 제대로 작동해도 프로젝트의 절반은 성공한 셈이에요!

4.1 Pydantic 스키마 만들기

우선 schemas.py에 사용자 관련 데이터 구조를 정의합니다:

from pydantic import BaseModel, EmailStr

class UserBase(BaseModel):
    username: str
    email: EmailStr

class UserCreate(UserBase):
    password: str

class User(UserBase):
    id: int

    class Config:
        orm_mode = True

4.2 SQLAlchemy 모델 정의

models.py에는 사용자 모델을 다음과 같이 정의해요:

from sqlalchemy import Column, Integer, String
from database import Base

class User(Base):
    __tablename__ = "users"

    id = Column(Integer, primary_key=True, index=True)
    username = Column(String(30), unique=True, nullable=False)
    email = Column(String(100), unique=True, nullable=False)
    hashed_password = Column(String(128), nullable=False)

💡 비밀번호는 평문 저장 No!

여기선 해시 없이 저장하겠지만, 실무에서는 꼭 bcrypt 같은 해싱 알고리즘을 사용해야 해요.

4.3 사용자 생성 API

# routers/users.py
from fastapi import APIRouter, HTTPException, Depends
from sqlalchemy.orm import Session
from database import get_db
import models, schemas

router = APIRouter(prefix="/users", tags=["Users"])

@router.post("/", response_model=schemas.User)
def create_user(user: schemas.UserCreate, db: Session = Depends(get_db)):
    existing_user = db.query(models.User).filter(
        (models.User.username == user.username) | (models.User.email == user.email)
    ).first()
    if existing_user:
        raise HTTPException(status_code=400, detail="Username or email already exists")

    db_user = models.User(
        username=user.username,
        email=user.email,
        hashed_password=user.password  # 실무에서는 해싱 필수!
    )
    db.add(db_user)
    db.commit()
    db.refresh(db_user)
    return db_user

4.4 사용자 조회 API

@router.get("/{user_id}", response_model=schemas.User)
def read_user(user_id: int, db: Session = Depends(get_db)):
    user = db.query(models.User).filter(models.User.id == user_id).first()
    if user is None:
        raise HTTPException(status_code=404, detail="User not found")
    return user

🧪 테스트 팁

  • Swagger UI(/docs)에서 POST → 바로 GET으로 테스트 가능!
  • uvicorn main:app --reload로 서버 실행하세요.

이제 사용자가 등록되고 조회되는 API가 완성되었습니다!

이 데이터를 기반으로 다음 단계에서는 본격적인 게시글(Post) 혹은 할일(Todo) 기능을 구현해보겠습니다.

 

 

5. 글쓰기 or 할일 등록 기능 구현 ✏️

이제 사용자 기능이 잘 작동하는 걸 확인했다면, 다음은 본 서비스의 중심 기능인 게시글(Post) 또는 할일(Todo)을 구현할 차례입니다.

블로그 API를 선택한 분은 글쓰기 기능을, Todo API를 선택한 분은 할일 등록 기능부터 차근차근 구현해보면 됩니다.

5.1 블로그 글쓰기 기능 (POST /posts/) 📝

# schemas.py
from datetime import datetime

class PostBase(BaseModel):
    title: str
    content: str

class PostCreate(PostBase):
    author_id: int

class Post(PostBase):
    id: int
    created_at: datetime
    author_id: int

    class Config:
        orm_mode = True
# models.py
from sqlalchemy import Column, Integer, String, ForeignKey, DateTime
from sqlalchemy.orm import relationship
from datetime import datetime

class Post(Base):
    __tablename__ = "posts"

    id = Column(Integer, primary_key=True, index=True)
    title = Column(String(100), nullable=False)
    content = Column(String, nullable=False)
    created_at = Column(DateTime, default=datetime.utcnow)
    author_id = Column(Integer, ForeignKey("users.id"), nullable=False)

    author = relationship("User", backref="posts")
# routers/posts.py
@router.post("/", response_model=schemas.Post)
def create_post(post: schemas.PostCreate, db: Session = Depends(get_db)):
    db_post = models.Post(
        title=post.title,
        content=post.content,
        author_id=post.author_id
    )
    db.add(db_post)
    db.commit()
    db.refresh(db_post)
    return db_post

5.2 글 목록 및 상세 조회 (GET /posts/, /posts/{id}) 📚

@router.get("/", response_model=List[schemas.Post])
def read_posts(skip: int = 0, limit: int = 10, db: Session = Depends(get_db)):
    posts = db.query(models.Post).offset(skip).limit(limit).all()
    return posts

@router.get("/{post_id}", response_model=schemas.Post)
def read_post(post_id: int, db: Session = Depends(get_db)):
    post = db.query(models.Post).filter(models.Post.id == post_id).first()
    if not post:
        raise HTTPException(status_code=404, detail="Post not found")
    return post

쿼리 파라미터로 skiplimit을 받아 간단한 페이징 기능도 적용해봤어요.

물론 실제 서비스라면 페이지 번호, 정렬 기준 등 더 다양한 필터가 필요하겠지만, 지금은 핵심 흐름만 익히는 게 중요합니다.

5.3 할일 등록 기능 (POST /todos/) ✅

# schemas.py
class TodoBase(BaseModel):
    title: str
    description: str

class TodoCreate(TodoBase):
    user_id: int

class Todo(TodoBase):
    id: int
    completed: bool
    priority: int

    class Config:
        orm_mode = True
# models.py
class Todo(Base):
    __tablename__ = "todos"

    id = Column(Integer, primary_key=True, index=True)
    title = Column(String(100), nullable=False)
    description = Column(String, nullable=False)
    completed = Column(Boolean, default=False)
    priority = Column(Integer, default=1)
    user_id = Column(Integer, ForeignKey("users.id"))

    user = relationship("User", backref="todos")
# routers/todos.py
@router.post("/", response_model=schemas.Todo)
def create_todo(todo: schemas.TodoCreate, db: Session = Depends(get_db)):
    db_todo = models.Todo(
        title=todo.title,
        description=todo.description,
        user_id=todo.user_id
    )
    db.add(db_todo)
    db.commit()
    db.refresh(db_todo)
    return db_todo

5.4 할일 목록 및 상세 조회 (GET /todos/, /todos/{id}) 📋

@router.get("/", response_model=List[schemas.Todo])
def read_todos(db: Session = Depends(get_db)):
    return db.query(models.Todo).all()

@router.get("/{todo_id}", response_model=schemas.Todo)
def read_todo(todo_id: int, db: Session = Depends(get_db)):
    todo = db.query(models.Todo).filter(models.Todo.id == todo_id).first()
    if not todo:
        raise HTTPException(status_code=404, detail="Todo not found")
    return todo

여기까지 완성되면 사용자 - 게시글, 또는 사용자 - 할일 구조의 기본 CRUD의 반 이상이 만들어진 셈입니다. 다음 단계에선 이 모든 기능들이 실제로 잘 작동하는지 테스트해보는 실습을 진행할 거예요!

 

 

6. 서버 실행 및 결과 테스트 ⚙️

이제 우리 프로젝트의 기본 기능은 모두 구현이 끝났습니다!

이제는 서버를 실행해보고, 실제 요청을 보내보며 테스트하는 단계입니다.

FastAPI의 가장 큰 장점 중 하나가 바로 Swagger UI를 통한 인터랙티브 테스트 환경이죠.

하나씩 점검하면서 내가 만든 API가 잘 작동하는지 직접 확인해봅시다.

6.1 서버 실행하기

uvicorn main:app --reload

이 명령어로 로컬 서버를 실행하면 http://127.0.0.1:8000/docs 에서 자동 생성된 Swagger 문서에 접속할 수 있습니다.

이제 각 API 기능을 직접 클릭해보며 테스트해볼 수 있어요.

6.2 주요 테스트 시나리오 🧪

  • POST /users/ : 사용자 등록 요청 → 성공 시 200 반환 및 ID 확인
  • GET /users/{id} : 등록한 사용자 조회 → 사용자 정보 반환
  • POST /posts/ 또는 /todos/ : 글 또는 할일 등록
  • GET /posts/ 또는 /todos/ : 전체 목록 확인
  • GET /posts/{id} 또는 /todos/{id} : 상세 페이지 확인

🚨 자주 발생하는 오류

  • IntegrityError: 이미 존재하는 username 또는 email → 400 예외 처리 필요
  • AttributeError: 'dict' object has no attribute → Pydantic 모델에 orm_mode = True 빠짐

6.3 마무리 점검 리스트 ✅

항목 확인 여부
DB 모델 생성 완료
Pydantic 스키마 정의
CRUD API 작동 확인
Swagger UI 테스트

축하합니다! 여기까지 완성했다면 여러분은 이제 FastAPI 기반의 실제 동작하는 백엔드 서비스를 손수 구현해본 경험을 쌓으신 거예요.

 

 

마무리 🎯

지금까지 FastAPI와 SQLAlchemy를 활용한 실전 API 프로젝트를 함께 구현해보았습니다.

단순한 Hello World 수준을 넘어, 사용자 생성부터 게시글/할일 등록, 조회 API까지 완성된 상태의 백엔드가 완성되었죠.

직접 설계한 데이터 모델, 모듈화된 프로젝트 구조, 그리고 인터랙티브한 Swagger UI 테스트까지. 이건 단순한 튜토리얼이 아니라, 실무 감각을 기를 수 있는 제대로 된 훈련이었어요.

 

이번 실습이 끝이 아니라는 점, 기억해주세요!

이후에는 글 수정 및 삭제 기능, 댓글 기능, JWT 인증 및 권한 관리, 에러 핸들링 구조화, pytest를 활용한 테스트 자동화 등 보다 확장된 기능을 다룰 예정입니다.

 

실제로 서비스를 만들고 싶다면 지금 만든 코드를 바탕으로 Docker, GitHub Actions, AWS EC2 배포까지 이어가볼 수 있겠죠? 이제 여러분 손에 달렸습니다.

지금 당장 터미널을 열고 새로운 아이디어로 코딩을 시작해보세요.

세상에 단 하나뿐인 여러분만의 API 서비스가 될 수도 있으니까요!

반응형

+ Recent posts