helm show values ${차트명}

values 내용을 파일로 추출

 helm show values ${차트명} > values.yaml

values.yaml을 차트에 오버라이드해서 설치하기

helm install -f values.yaml ${사용자 지정 Release 이름} ${설치하려는 차트 이름}

windows 환경에서 Rancher Desktop을 사용 중인데, kubernetes 버전을 1.28.5 버전으로 올린 이후로 kubectl 명령어 사용시 해당 에러가 발생하였다.

I0111 11:20:45.321675   34884 versioner.go:88] Right kubectl missing, downloading version 1.15.3
F0111 11:20:45.635763   34884 main.go:70] error while trying to get contents of https://storage.googleapis.com/kubernetes-release/release/v1.15.3/bin/windows/amd64/kubectl.exe.sha256: GET https://storage.googleapis.com/kubernetes-release/release/v1.15.3/bin/windows/amd64/kubectl.exe.sha256 returned http status 404 Not Found

원인

kubectl 과 Rancher로 기동한 kubernetes간 버전이 달라서 발생하는 이슈로 kubectl 버전을 업그레이드하는 방법으로 해결할 수 있다.

해결법

cmd창(명령 프롬프트)에서 아래 명령어를 입력하여 신규 버전으로 설치하는 방법 bash curl.exe -LOk "https://dl.k8s.io/release/<kubectl 버전>/bin/windows/amd64/kubectl.exe"

1. 프로젝트 초기화 및 필수 모듈 설치

   
   npx create-react-app myApp --template typescript
   npm i --save-dev @types/styled-components
   npm i styled-components
   npm i recoil

2. /src 디렉토리에 App.tsx, index.tsx 파일 제외한 불필요한 파일 삭제

3. index.tsx파일 기본 세팅 적용

   
   import React from 'react';
   import ReactDOM from 'react-dom/client';
   import App from './App';
   import { RecoilRoot } from 'recoil';
   import { ThemeProvider } from 'styled-components';
   import { darkTheme } from './theme';
   
   const root = ReactDOM.createRoot(
    document.getElementById('root') as HTMLElement
   );
   root.render(
    <React.StrictMode>
        <RecoilRoot>
          <ThemeProvider theme={darkTheme}>
            <App />
          </ThemeProvider>
        </RecoilRoot>
    </React.StrictMode>
   );
   

스타일 적용

기본 테마 인터페이스 재정의

1. /src 디렉토리에 style.d.ts파일 생성

   
   import "styled-components";
   
   declare module "styled-components" {
      export interface DefaultTheme {
          textColor: string;
          bgColor: string;
          accentColor: string;
      }
   }

2. /src 디렉토리에 theme.ts파일 생성

   
   import { DefaultTheme } from "styled-components";
   
   export const darkTheme : DefaultTheme = {
      bgColor: "#2f3640",
      textColor: "#7f8fa6",
      accentColor: "#9c88ff",
   };
   
   export const lightTheme : DefaultTheme = {
      bgColor: "whitesmoke",
      textColor: "black",
      accentColor: "#9c88ff",
   };

3. App.tsx에 전역 스타일 설정 추가

   
    import React from 'react';
    import { createGlobalStyle } from 'styled-components';
   
    const GlobalStyle = createGlobalStyle`
    @import url('https://fonts.googleapis.com/css2?family=Source+Sans+3:wght@300&display=swap');
    html, body, div, span, applet, object, iframe,
    h1, h2, h3, h4, h5, h6, p, blockquote, pre,
    a, abbr, acronym, address, big, cite, code,
    del, dfn, em, img, ins, kbd, q, s, samp,
    small, strike, strong, sub, sup, tt, var,
    b, u, i, center,
    dl, dt, dd, menu, ol, ul, li,
    fieldset, form, label, legend,
    table, caption, tbody, tfoot, thead, tr, th, td,
    article, aside, canvas, details, embed,
    figure, figcaption, footer, header, hgroup,
    main, menu, nav, output, ruby, section, summary,
    time, mark, audio, video {
      margin: 0;
      padding: 0;
      border: 0;
      font-size: 100%;
      font: inherit;
      vertical-align: baseline;
    }
    /* HTML5 display-role reset for older browsers */
    article, aside, details, figcaption, figure,
    footer, header, hgroup, main, menu, nav, section {
      display: block;
    }
    /* HTML5 hidden-attribute fix for newer browsers */
    *[hidden] {
        display: none;
    }
    body {
      line-height: 1;
    }
    menu, ol, ul {
      list-style: none;
    }
    blockquote, q {
      quotes: none;
    }
    blockquote:before, blockquote:after,
    q:before, q:after {
      content: '';
      content: none;
    }
    table {
      border-collapse: collapse;
      border-spacing: 0;
    }
    * {
      box-sizing : border-box;
    }
    body {
      font-family: 'Source Sans 3', sans-serif;
      background-color: ${props => props.theme.bgColor};
      color:${props => props.theme.textColor}
   
    }
    a {
      text-decoration: none;
      color:inherit;
    }
    `;
   
    function App() {
      return (
        <>
          <GlobalStyle />
        </>
      );
    }
   
    export default App;

• 특정 HTTP 메서드(GET, POST 등)와 관련된 코드를 조건 분기 대신 별도의 메서드를 사용하여 처리할 수 있습니다.
• 다중상속(multiple inheritance)과 같은 객체 지향 기법을 사용하여 코드를 재사용 가능한 구성 요소로 분리할 수 있습니다.

그리고 뷰 개발에서 흔히 발견되는 관용구와 패턴을 추상화하고 일반적인 경우에 뷰 개발을 용이하게 하기 위해 자주 쓰는 클래스 기반 뷰들을 미리 만들어서 제공하고 있는데, 이 뷰를 제네릭 뷰라고 합니다.

Django에서 제공하는 클래스 기반 뷰 및 제네릭 뷰에 대한 자세한 정보는 아래 링크를 참고바랍니다.

Built-in class-based views API

자 그러면 지금까지 만든 코드에 이것을 한 번 적용해봅시다.

뷰 파일 수정하기

먼저, 기존에 함수 기반 뷰로 작성된 test_app/views.py파일의 해당 부분을 수정해봅시다.

...
def index(request):
    latest_book_list = TestBook.objects.order_by("-reg_datetime")[:5]
    context = {"latest_book_list" : latest_book_list,}
    return render(request, "book/index.html", context)

def book(request, book_id):
    book = get_object_or_404(TestBook, pk=book_id)
    return render(request, "book/detail.html",  {"book": book, "range":range(10)})

def comment(request, book_id):
...

아래는 클래스 기반 뷰로 변경한 형태입니다.

...
from django.views.generic import (
    ListView,
    DetailView,
)

class BookIndexView(ListView):
    template_name = "book/index.html"
    context_object_name = "latest_book_list"

    def get_queryset(self):
        return TestBook.objects.order_by("-reg_datetime")[:5]

class BookDetailView(DetailView):
    model = TestBook
    template_name = "book/detail.html"
    context_object_name = 'book'

    def get_context_data(self, **kwargs: Any) -> Dict[str, Any]:
        context_data = super().get_context_data(**kwargs)
        context_data['range'] = range(10)      
        return context_data

def comment(request, book_id):
...

기존 index() 함수는 BookIndexView 클래스로 전환되었으며 BookIndexView는 목록의 형태로 데이터를 보여주기 때문에 ListView라는 제네릭뷰를 상속받도록 설정합니다.

Python 언어에서의 상속은 아래와 같은 형태로 상속관계를 설정할 수 있습니다.

class 클래스명(상속받을 부모클래스명)

함수의 입력 파라미터와 형태가 비슷해 보이나 전혀 다른 개념이므로 혼동되지 않도록 합니다.

그리고 필요한 값들을 미리 정해둔 변수값에 입력받는 형식으로 작성을 하게 됩니다. BookIndexView 예시는 template_name 변수에 사용자 화면에 바탕이 될 템플릿의 이름(파일경로)를 작성하고, context_object_name값을 설정하여 화면에 목록으로 보여질 모델의 목록 객체의 이름을 'latest_book_list'로 선언했습니다.

그리고 화면에 뿌려질 모델을 가져오기 위한 메서드인 get_queryset() 함수는 기존에 모델을 최근 5개까지의 모델들을 목록으로 리턴하도록 재정의(override)하였습니다.

목록을 보여주는 뷰 뿐만 아니라 실제 다른 제네릭 뷰를 사용하더라도 위 예시와 같이 용도에 맞는 제네릭 뷰 클래스를 상속받게 설정한 후 부모클래스에서 미리 정의된 멤버변수에 필요한 값들을 채워 넣고 필요한 메서드를 재정의(override)하는 형식으로 구현된다고 보시면 됩니다.

기존 book 함수도 BookDetailView 클래스로 전환되었으며, 마찬가지로 제네릭 뷰의 DetailView를 상속받아서 구현되었습니다.

model변수에 모델로 사용할 테이블 모델 클래스를 지정하고, template_name과 context_object_name에 각각 화면에 노출시킬 템플릿 명과 그 템플릿을 이용하여 화면에 그릴 때 필요한 모델 객체 데이터를 담을 변수의 이름을 선언했습니다. 또 context_data라는 딕셔너리 객체에 range라는 키를 추가하여 템플릿에서 평점 입력을 위한 라디오 버튼을 생성할 때 필요한 값을 함께 리턴하도록 재정의(override)하였습니다.

참고로 context_object_name은 별도로 설정하지 않으면 기본값으로 모델 객체가 내려가게 됩니다. 하지만 기본값을 사용하지 않고 수정한 이유는 만들어 두었던 템플릿 파일을 그대로 활용할 수 있게 하기 위함입니다.

예를 들어 기존에 작성해뒀던 templates/book/index.html를 한 번 살펴봅시다.

templates/book/index.html

<h3>신간도서</h3>
{% if latest_book_list %}
<ul class="list-group">
  {% for book in latest_book_list %}
  <li>
    <a href="{% url 'bookstore:detail' book.id %}">{{ book.title }}</a>
  </li>
  {% endfor %}
</ul>
{% else %}
<p>No books are available.</p>
{% endif %}

views.py에서 context_object_name을 이미 기존 템플릿 파일내에서 사용하는 이름으로 바꿔주었기 때문에 템플릿 파일들은 별도 수정없이 그대로 사용할 수 있게 되었습니다.

context_object_name의 기본값은 제네릭 뷰가 상속받는 Mixin에 따라 이름이 결정됩니다. 예를 들어 제네릭 뷰가 SingleObjectMixin을 상속받는 단일 개체를 위한 뷰라면 모델명이 곧 이름이 됩니다. 하지만 ListView와 같이 복수 개체를 위한 뷰라면 MultipleObjectMixin을 상속받기 때문에 모델명 뒤에 '_list'라는 이름으로 디폴트 값이 정해지게 됩니다. ex) Book 모델 단일 개체용 뷰에서의 기본값 : book Book 모델 복수 개체용 뷰에서의 기본값 : book_list

믹스인(Mixin) 이란? Mixin은 python에서 제공하는 다중상속을 활용한 클래스의 한 종류입니다. 하지만 일반적인 클래스 상속의 개념과는 다르게 재사용되는 코드의 파편, 즉 스스로는 별 의미를 가지지 않지만 상속받는 클래스에게 부가적인 기능을 추가시켜주는 용도로 사용하는 클래스입니다.

URL 설정파일 수정하기

다음으로 만들어진 클래스 기반뷰로 라우팅 되도록 test_app/urls.py 파일도 수정해 줍니다.

...
from . import views

app_name = "bookstore"
urlpatterns = [
    path("", views.BookIndexView.as_view(), name="index"),
    path("<int:pk>/", views.BookDetailView.as_view(), name="detail"),
...
]

• 서평(comment) 달기
• 평점 등록
• 서평에 좋아요, 싫어요 기능

먼저 test_app/models.py에 서평에 대한 내용을 담을 모델을 신규로 생성합니다.

...
class TestBook(models.Model):
    ...
    rating=models.FloatField(null=True, blank=True)

    def __str(self):
    ...


class TestBookComment(models.Model):
    book = models.ForeignKey(TestBook, on_delete=models.CASCADE)
    content = models.TextField(max_length=1000)
    scroe = models.IntegerField(default=0)
    likes = models.IntegerField(default=0)
    dislikes = models.IntegerField(default=0)

    def __str__(self):
        return self.content

    def check_acceptance(self, threshold_ratio=0.5):
        total_votes = self.likes + self.dislikes
        if total_votes == 0:
            return False

        like_ratio = self.likes / total_votes

        if like_ratio >= threshold_ratio:
            return True
        else:
            return False

TestBook에 평점을 저장할 변수 rating을 추가하고, 여러 개의 서평을 달 수 있도록 TestBookComment 테이블 모델 클래스와 1:N 관계를 만들어 주기 위해 ForeignKey 필드를 통해 관계를 정의했습니다. 그리고 나머지 각 변수의 역할은 다음과 같습니다.

• content : 서평 본문 내용
• score : 추천도(점수)
• likes : 이 서평에 대한 좋아요 수
• dislikes : 이 서평에 대한 싫어요 수

그리고 check_acceptance()라는 함수를 만들어 '좋아요' 수와 '싫어요' 수의 비율에 따라 이 서평의 평가점수가 책의 평점 집계에 채택되는지 여부를 확인할 수 있게 했습니다.

다음으로 test_app/templates/book/detail.html 뷰에 서평을 달 수 있는 코드 및 html 마크업을 추가합니다.

** /templates/book/detail.html 전문 **

<h3>{{ book.title }}</h3>
<table border="1">
  <th>도서번호</th>
  <th>카테고리</th>
  <th>가격</th>
  <th>등록일자</th>
  <tr>
    <td>{{ book.id }}</td>
    <td>{{ book.category.categoryName }}</td>
    <td>{{ book.price }}</td>
    <td>{{ book.reg_datetime }}</td>
  </tr>
</table>

<h4>서평 목록</h4>
<ul>
  {% for comment in book.testbookcomment_set.all %}
  <li>
    <p>{{ comment.content }} -- {{ comment.score }}</p>
    <p>
      <button type="button" onclick="">👍</button> : {{ comment.likes }}
      <button type="button">👎</button> : {{ comment.dislikes }}
    </p>
  </li>
  {% endfor %}
</ul>

<h4>서평 쓰기</h4>
<form action="{% url 'bookstore:comment' book.id %}" method="post">
  {% csrf_token %}

  <fieldset class="rate" style="width: 500">
    <b>추천도</b>
    {% for i in range %}
    <input
      type="radio"
      id="score{{ forloop.revcounter }}"
      name="score"
      value="{{ forloop.revcounter }}"
    /><label
      class="half"
      for="score{{ forloop.revcounter }}"
      title="{{ forloop.revcounter }}점"
      >{{ forloop.revcounter }}</label
    >
    {% endfor %}
  </fieldset>
  <textarea name="comment" cols="100" rows="10" maxlength="1000"></textarea>
  <input type="submit" value="Comment" />
</form>

<a href="{% url 'bookstore:index' %}">홈으로</a>

기존에 작성했던 책의 자세한 정보를 보여주는 테이블 아래에 해당 책에 달려있는 서평 목록과 그 밑에 form 태그를 이용하여 서평을 작성할 수 있는 양식을 추가했습니다. 추천도는 10점부터 1점까지 점수를 줄 수 있도록 라디오 버튼을 10개 만들기 위해 django templates의 _for_태그 이용해서 버튼을 만들어 줬습니다. _for_에 대한 설명은 이 포스팅을 참고바랍니다.

참고
django templates의 보안정책으로 인해 _for_태그는 python의 range() 함수를 바로 사용할 수 없습니다. 우선은 range라는 리스트변수로 for 루프를 돌게 작성해두고, 추후 view 코드에서 range 변수를 넘겨받아 for 루프를 돌 수 있게 해줍니다.

참고 Django 템플릿 시스템에서 python의 for 반복문과 range 함수를 지원하지 않는 이유는 보안과 템플릿의 분리를 강화하기 위함입니다. Django 템플릿 시스템은 주로 HTML과 같은 템플릿 코드를 뷰 코드와 분리하여 유지보수를 용이하게 합니다. 따라서 템플릿 코드는 보통 웹 디자이너나 프론트엔드 개발자가 작성하고, 뷰 코드는 백엔드 개발자가 작성하는 것이 일반적입니다. 이러한 템플릿과 뷰의 분리는 보안 측면에서 중요합니다. python의 for 반복문과 range 함수를 템플릿에서 사용한다면, 템플릿 코드에 python의 로직이 포함되기 때문에 보안상 취약점이 발생할 수 있습니다. 특히, 템플릿 코드에 복잡한 로직이 포함되면 웹 애플리케이션의 취약점이 노출될 수 있으며, 이는 악의적인 사용자에게 악용될 수 있습니다.

다음으로 test_app/templates/book/results.html 파일을 추가하여 서평을 작성하고 제출을 했을 때 노출할 페이지를 만들어 줍니다.

<h1>{{ book.title }}</h1>

<p>서평이 등록되었습니다.</p>

<a href="{% url 'bookstore:detail' book.id %}">돌아가기</a>

이제 test_app/views.py에 서평을 달 수 있는 뷰 코드를 작성합니다.

def book(request, book_id):
    book = get_object_or_404(TestBook, pk=book_id)
    return render(request, "book/detail.html",  {"book": book, "range":range(10)})


def comment(request, book_id):
    book = get_object_or_404(TestBook, pk=book_id)
    comment = TestBookComment(
        book = book,
        content = request.POST["comment"],
        score = request.POST["score"]
    )
    comment.save()
    return HttpResponseRedirect(reverse("bookstore:results", args=(book.id,)))

def results(request, book_id):
     book = get_object_or_404(TestBook, pk=book_id)
     return render(request, "book/results.html", {"book":book})    

먼저 book()함수에 추천도 버튼을 만드는데 사용할 range변수를 추가해줍니다. 10개의 값이 필요하므로 range 변수에 range(10)함수를 담아 book/detail.html로 보내도록 수정해줍니다.

comment()함수는 detail 뷰에서 서평 및 점수를 작성한 후 submit 버튼을 눌렀을 때 호출되는 함수입니다. 먼저 해당 책이 존재하는지 체크하고 있으면 해당 책의 서평을 저장하는 로직으로 동작합니다. 그 후 bookstore:results url로 리다이렉트 되도록 설정했습니다.

마지막으로 서평 작성 완료 화면을 노출시키기 위한 result()함수를 추가해 줍니다.

이제 작성한 내용은 url를 연결시켜주기 위해 test_app/urls.py를 수정합니다.

...
   path("<int:book_id>/comment", views.comment, name="comment"),
   path("<int:book_id>/results", views.results, name="results"),
...

다 됐으면 서버를 기동시켜 봅니다.

반복문을 통해 리스트를 순회하려면 다음과 같이 사용합니다.

{% for x in x_list %}
    {{ x }}
{% endfor %}

뒤에서 부터 역순으로 순회하기 위한 다음 옵션도 있습니다.

{% for x in x_list reversed %}
    {{ x }}
{% endfor %}

그리고 다음과 같은 다양한 기본 변수들도 제공합니다.

반복문 관련 제공 변수

비어있는 리스트에 대한 처리

for ... empty 태그를 통해 반복문을 실행하고자 하는 리스트가 비어 있을 경우에 대한 처리 방법을 제공합니다.

<ul>
{% for x in x_list %}
    <li>{{ x }}</li>
{% empty %}
    <li>no items in this list.</li>
{% endfor %}
</ul>

따라오면서 자세히 보셨으면 아시겠지만, Database의 연결정보와 SecretKey 정보와 DB 연결정보 등의 보안이 필요한 민감성 정보들은 대부분 setting.py에 등록해서 사용하고 있습니다. 그렇기 때문에 이 파일을 그대로 github 등에 올리는 것은 보안위협에 그대로 노출되는 매우 어처구니 없는 상황이 발생하게 됩니다.

그래서 이번에는 settings의 민감성 정보들을 어떻게 숨기고 별도로 관리하는지에 대해 알아봅시다.

시크릿 파일 생성

먼저 별도로 관리할 시크릿 파일을 하나 만듭니다. 저는 프로젝트 디렉토리 최상단 manage.py와 같은 위치에 .secrets.json 파일을 하나 생성했습니다.

{
    "secretKey" : "iam-secret-key-for-django",

    "databases":{
        "common": {
            "username": "username123",
            "password": "password123",
            "host": "127.0.0.1",
            "port": "3306"
        },
    }
}

이 json 파일을 읽어올 수 있도록 /test_project/settings.py에 다음 코드를 추가합니다.

import os, json

secret_file = os.path.join(BASE_DIR, '.secrets.json')

# secrets.json 파일을 읽은 후 secrets 변수에 저장
with open(secret_file) as f:
    secrets = json.loads(f.read())

# get_secret 함수를 생성하여 호출 시 해당 키 값 리턴
def get_secret(*args, secrets=secrets):
    if len(args) == 0:
        raise ValueError("At least one JSON string is required.")

    try:
        result = secrets
        for key in args[0:]:
            result = result[key]
        return result
    except KeyError as e:
        raise ValueError(f"Key '{str(e)}' not found in the JSON data.")    

이렇게 시크릿 파일을 읽을 준비가 되면, 민감성 정보가 필요한 곳에 적용해줍니다.

...
SECRET_KEY = get_secret("secretKey")

...

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'common',
        'USER': get_secret("databases", "common", "username"),
        'PASSWORD': get_secret("databases", "common", "password"),
        'HOST': get_secret("databases", "common", "host"),
        'PORT': get_secret("databases", "common", "port"),
    },
...

이렇게 설정하고 정상적으로 서버가 동작하는지 확인해봅시다. 정상적으로 동작한다면 git에 푸시할 때 .secrets.json 파일은 .gitignore 파일에 추가하여 git 저장소에 같이 푸시되지 않도록 처리합니다.

이렇게 작업하면 일단 민감성 정보 숨기는 작업을 끝났습니다.

Git History에 이미 푸시된 민감정보 삭제

만약 이미 git에 해당 정보가 포함된 settings.py가 git에 푸시되어 있다면, 이 작업을 해도 히스토리 보기를 통해 과거의 내용을 볼 수 있습니다. 이런 경우를 위해 히스토리까지 싹 날리는 여러 방법이 존재합니다. 그 중 간단한 방법으로 git-filter-repo 패키지를 이용하여 삭제해봅시다.

먼저 다음 명령어로 git-filter-repo 패키지를 설치합니다.

sudo apt-get install git-filter-repo

그리고 다음 명령을 통해 히스토리를 삭제할 파일을 정해 삭제합니다.

주의! 해당 명령을 실행하면 settings.py 파일자체가 삭제되어 버리니 시크릿파일을 통해 민감정보 가져오기 작업된 settings.py 파일은 따로 백업해놓고 해당 작업 이후 재커밋해주셔야 합니다.

git filter-repo --invert-paths --path config/settings.py --force

이제 히스토리 보기를 해도 민감정보 작업 전 히스토리 내역은 보이지 않게 되었습니다.

이 경우 환경변수가 어떠한 이유로 인해 제거된 것으로 다시 환경변수를 추가해주면 정상적으로 동작하게 됩니다.

[해결 방법]

1. Windows 키 + r 입력하여 실행창을 열어 sysdm.cpl ,3 입력 후 엔터. (혹은 작업표시줄 검색창에서 환경변수 검색)

2. 고급 탭에서 환경 변수(N)버튼 클릭

3. 사용자 변수 혹은 시스템 변수에서 Path 변수 편집버튼 클릭

4. Path 변수항목에 C:\Users\{사용자이름}\AppData\Local\Microsoft\WindowsApps을 추가한다. _(Microsoft store를 통해 설치한 경우) _

5. 확인버튼을 눌러 설정창을 닫고 Windows Terminal 다시 실행하여 정상 출력 확인!

오늘은 지금까지 작성했던 테스트코드를 바탕으로 아래와 같은 View를 작성하고, 사용자에게 보여질 Template연동까지 해보도록 하겠습니다.

• 도서 색인 페이지 : 최근에 등록된 도서목록을 최근 5개까지 보여줍니다.
• 도서 상세 페이지 : 도서의 상세정보를 보여 줍니다.
• 도서 분류 페이지 : 카테고리별로 대상 카테고리에 속하는 도서 목록을 보여줍니다.

View 적용하기

먼저 도서 색인 페이지를 추가해보도록 하겠습니다. test_app/views.py 파일 내의 index() 뷰를 다음과 같이 변경합니다.

from django.http import HttpResponse

def index(request):
    latest_book_list = TestBook.objects.order_by("-reg_datetime")[:5]
    output = ", ".join([b.title for b in latest_book_list])
    return HttpResponse(output)

코드를 간략히 설명하면 TestBook 테이블 오브젝트로 부터 reg_datetime 내림차순으로 정렬된 데이터(오름차순으로 정렬하려면 '-' 제거) 중 상위 5개만 가져와 latest_book_list 변수에 담아 응답을 내려주고 있습니다.

다음으로 test_app/urls.py 파일을 수정하여 각 페이지로 접속할 수 있는 url를 매핑합니다.

from django.urls import path
from . import views

urlpatterns = [
    path("", views.index, name="index"),
    path("book/<int:book_id>/", views.book, name="book"),
    path("book/category/<int:category_id>/", views.bookCategory, name="category")
]

Template 연동하기

이제 템플릿을 연동하여 사용자에게 보여줄 화면을 그리는 작업을 진행하겠습니다.

먼저 index() 뷰 로직을 다음과 같이 수정합니다.

from django.http import HttpResponse

def index(request):
    latest_book_list = TestBook.objects.order_by("-reg_datetime")[:5]
    template = loader.get_template("index.html")
    context = {"latest_book_list" : latest_book_list,}
    return HttpResponse(template.render(context, request))

기존 로직으로 latest_book_list를 가져와서 context변수에 담고 index.html 템플릿을 불러와서 동적으로 index.html에 context 데이터를 넣어 화면을 그려서 응답을 주도록 코드를 작성했습니다.

다음으로 템플릿으로 사용할 index.html 파일을 만들어봅시다.

기본적으로 django 템플릿은 /templates 디렉토리에서 스캔하게 되므로 test_app/templates 폴더를 하나 생성합니다.

그리고 나서 도서 색인페이지를 위한 index.html 파일을 아래 코드와 같이 생성합니다.

<h3>신간도서</h3>
{% if latest_book_list %}
<ul>
  {% for book in latest_book_list %}
  <li><a href="test/book/{{ book.id }}/">{{ book.title }}</a></li>
  {% endfor %}
</ul>
{% else %}
<p>No books are available.</p>
{% endif %}

중괄호로 시작하는 부분들이 DjangoTemplates언어로 작성된 코드들이며 HTML 마크업 사이에 끼어서 동적으로 데이터를 표시하여 유저에게 보여줄 수 있도록 합니다.

DjangoTemplates이란? Django 웹 프레임워크에서 사용되는 템플릿 언어입니다. Template은 HTML과 Python 코드를 결합하여 동적으로 데이터를 표시하고 조작할 수 있도록 도와줍니다. settings.py에서 TEMPLATES항목을 통해 템플릿 엔진을 설정할 수 있으며, 기본값으로 DjangoTemplates를 사용하도록 설정되어 있습니다.

Shortcut 모듈을 활용하여 코드 간결화하기

템플릿에 context를 채워넣어 표현한 결과를 HttpResponse 객체와 함께 돌려주는 구문은 자주 쓰는 용법입니다. Django는 이러한 작업을 쉽게 작성 할 수 있도록 단축 기능(shortcuts)을 제공합니다. index() 뷰를 단축 기능으로 작성하면 다음과 같습니다.

from django.shortcuts import render

def index(request):
    latest_book_list = TestBook.objects.order_by("-reg_datetime")[:5]
    context = {"latest_book_list" : latest_book_list,}
    return render(request, "index.html", context)

모든 뷰에 적용한다면 더 이상 loader와 HttpResponse를 별도로 임포트하지 않아도 되기 때문에 앞으로 나올 코드들은 shortcuts를 적용하여 코드를 작성하도록 하겠습니다.

이제 코드를 실행해서 인덱스 페이지에 접근하면 다음과 같은 화면이 노출됩니다. 책의 목록은 관리자페이지에서 임의로 생성하였으므로, 실습하실 때 여러개 임의로 추가해서 확인하면 됩니다.

에러 발생시키기

이제 도서 상세 페이지와 도서 분류페이지도 작성하도록 하겠습니다. 코드를 작성하면서 존재하지 않는 상세 페이지나 분류페이지를 호출했을 때 에러를 노출하도록 해보겠습니다.

먼저 /test_app/views.py 파일에 다음 함수들을 추가합니다.

from django.http import Http404
//...

def book(request, book_id):
    try:
        book = TestBook.objects.get(pk=book_id)
    except TestBook.DoesNotExist:
        raise Http404("The Book does not exist")
    return render(request, "book/detail.html",  {"book": book})

def bookCategory(request, category_id):
    try:
        category = TestBookCategory.objects.get(pk=category_id)
        books = TestBook.objects.filter(category_id=category_id)
    except TestBookCategory.DoesNotExist:
        raise Http404("The Category does not exist")
    return render(request, template_name="category/detail.html", context={"category": category, "books":books})

Django는 Python의 try-except문을 이용하여 예외를 잡아낼 수 있으며 이를 이용하여 해당 테이블 오브젝트에 요청된 데이터가 없을 시에 Http404에러를 던지도록 코드를 작성했습니다.

Shortcut 모듈을 활용하여 코드 간결화하기

404에러를 반환하는 로직도 render 로직과 마찬가지로 Shortcut을 제공하여 간결하게 표현할 수 있습니다.

from django.shortcuts import get_object_or_404, render
//...

def book(request, book_id):
    book = get_object_or_404(TestBook, pk=book_id)
    return render(request, "book/detail.html",  {"book": book})

def bookCategory(request, category_id):
    category = get_object_or_404(TestBookCategory, pk=category_id)
    books = TestBook.objects.filter(category_id=category_id)
    return render(request, template_name="category/detail.html", context={"category": category, "books":books})

템플릿 활용하기

도서 상세 페이지와 도서 분류 페이지의 템플릿파일을 /test_app/templates/book/detail.html 과 /test_app/templates/category/detail.html에 각각 생성한 후 템플릿을 다음과 같이 작성합니다.

/book/detail.html

<h3>{{ book.title }}</h3>
<table border="1">
  <th>도서번호</th>
  <th>카테고리</th>
  <th>가격</th>
  <th>등록일자</th>
  <tr>
    <td>{{ book.id }}</td>
    <td>{{ book.category.categoryName }}</td>
    <td>{{ book.price }}</td>
    <td>{{ book.reg_datetime }}</td>
  </tr>
</table>

/category/detail.html

<h3>{{ category.categoryName }}</h3>
<table border="1">
  <th>도서명</th>
  {% for book in books %}
  <tr>
    <td>{{ book.title}}</td>
  </tr>
  {% endfor %}
</table>

/book/detail.html과 같이 템플릿 시스템에서 각 변수의 속성에 접근하기 위해서는 점-탐색(dot-lookup)문법을 사용해서 접근합니다. django는 먼저 book 객체에 대해 사전형으로 먼저 탐색을 시도하고 실패하면 속성값으로 탐색을 시도합니다. 속성으로도 탐색을 실패하면 리스트의 인덱스 탐색을 시도합니다.

/category/detail.html과 같이 {% for %}을 이용하여 반복분도 사용할 수 있습니다.

템플릿에서 하드코딩된 url 제거하기

앞서 /test/index.html에서 상세 페이지로 접근하는 링크가 하드코딩되어 있었습니다. 하드코딩된 URL은 코드가 강한 의존성을 갖게 되어 수많은 템플릿을 가질수록 수정하기 힘들어집니다.

이 부분을 해소하기 위해 템플릿에서 하드코딩 된 url을 제거해봅시다.

/test_app/urls.py에서 path() 함수에서 인수의 이름을 정의했으므로, {% url %} template 태그를 사용하여 url 설정에 정의된 특정한 URL 경로들의 의존성을 제거할 수 있습니다.

/test_app/templates/index.html

<h3>신간도서</h3>
{% if latest_book_list %}
<ul>
  {% for book in latest_book_list %}
  <li><a href="{% url 'book' book.id %}">{{ book.title }}</a></li>
  {% endfor %}
</ul>
{% else %}
<p>No books are available.</p>
{% endif %}

URL의 네임스페이스 지정하기

실제로 Django 프로젝트는 앱이 여러개가 될 수 있습니다. 그렇게 되면 이 앱들간의 URL을 구분하는 방법이 필요해지게 됩니다.

예를 들어 우리가 만든 test_app의 index라는 이름의 url이 있지만 다른 앱에서도 index라는 url이 있을 경우 서로 URL을 구분할 수 있어야 합니다.

즉, Django가 {% url %} 템플릿태그를 사용할 때, 어떤 앱의 뷰에서 URL을 생성할지 알 수 있어야 합니다.

이것은 URLconf에 네임스페이스(namespace)을 추가하여 해결할 수 있습니다.

test_app/urls.py파일에 다음과 같이 app_name을 추가하여 어플리케이션의 네임스페이스를 설정할 수 있습니다.

test_app/urls.py

app_name = "bookstore"
urlpatterns = [
    path("", views.index, name="index"),
    path("book/<int:book_id>/", views.book, name="book"),
    path("book/category/<int:category_id>/", views.bookCategory, name="category")
]

test_app/templates/index.html

<h3>신간도서</h3>
{% if latest_book_list %}
<ul>
  {% for book in latest_book_list %}
  <li><a href="{% url 'bookstore:book' book.id %}">{{ book.title }}</a></li>
  {% endfor %}
</ul>
{% else %}
<p>No books are available.</p>
{% endif %}

컨텐츠를 수정하기 위해 관리자 사이트를 별도로 따로 만들 필요없이 제법 그럴듯한 관리자 사이트를 제공합니다. Django는 모델에 대한 관리용 인터페이스를 모두 자동 생성하고, 이를 admin 모듈에 알려주기만 하면 바로 관리 기능을 사용할 수 있습니다.

관리자 계정 생성하기

먼저 다음 명령으로 관리자 사이트에 로그인 할 수 있는 사용자를 생성합니다.

$ python manage.py createsuperuser
Username (leave blank to use 'admin'): harry
Email address: harry@email.com
Password:
Password (again):
Superuser created successfully.

• Username : 원하는 운영자 id를 입력합니다.
• Email address : 원하는 이메일 주소를 입력합니다.
• Password : 로그인 시 사용할 암호를 입력합니다. (두 번 입력)

관리자 사이트 접속하기

관리자 사이트는 별도 프로젝트가 따로 있는게 아니라 우리가 작업하던 프로젝트에 같이 포함되어 실행이 됩니다. 다음 명령으로 서버를 시작합니다.

$ python manage.py runserver

서버가 뜨면 웹 브라우저를 열고 /admin 도메인으로 이동합니다. (예: http://127.0.0.1:8000/admin/).

로그인 화면이 노출되면 위에서 생성한 운영자 계정으로 로그인을 합니다. 로그인에 성공하게 되면 다음과 같은 화면이 보입니다. 이 페이지에서는 그룹과 사용자의 인증,권한을 관리하는 기능이 보입니다. 이 기능들은 django.contrib.auth 모듈에서 제공하는데 INSTALLED_APPS항목에 기본적으로 등록되어 있던 모듈입니다.

그런데 관리자페이지에 권한관리 기능만 있으니 허전합니다. 우리가 만든 앱에 대해서 관리 페이지를 만들어 봅시다.

관리자 사이트에 관리기능 등록하기

우리가 만든 모델 클래스의 관리 인터페이스가 있다는 것을 인식시키기 위해 test_app/admin.py파일을 열어 다음과 같이 모델을 등록하고 코드를 추가합니다.

from django.contrib import admin
from .models import TestBook
from .models import TestBookCategory
from .models import TestMember

# Register your models here.
admin.site.register(TestBook)
admin.site.register(TestBookCategory)
admin.site.register(TestMember)

코드를 추가한 뒤 다시 실행시켜 접속해보면 다음과 같이 테이블 모델들의 목록이 보이게 됩니다.

여기서 Test Books 항목으로 들어가보면, 이전에 추가한 책 목록들이 보이고, 여기서 ADD TEST BOOK버튼을 눌러 신규 책을 등록할 수 있습니다.

그리고 여기서 기존에 등록했던 책 타이틀을 클릭하면 내용을 수정할 수 있습니다.

모델의 각 필드 유형들은 models.py에 작성된 타입에 맞게 적절한 HTML 입력 위젯으로 표현됩니다. 그리고 연결관계로 묶여있는 Category까지 여기서 추가, 편집할 수 있다니 신경써서 잘 만든게 느껴지네요.

지난 번에는 DB에 수동으로 테이블을 생성한 뒤 inspectdb 명령을 통해서 만들어진 모델을 이용해서 테이블에 데이터를 삽입해 봤다면, 이번에는 모델을 통해 테이블 생성 및 데이터 삽입하는 방법을 알아보겠습니다.

먼저 models.py에 신규로 생성할 테이블의 모델을 추가합니다.

from django.db import models

...
class TestBookCategory(models.Model):
    categoryName = models.CharField(max_length=20)

class TestBook(models.Model):
    title = models.CharField(max_length=200)
    category = models.ForeignKey(TestBookCategory, on_delete=models.SET_NULL, null=True)
    price = models.IntegerField()
    reg_datetime = models.DateTimeField()
...

데이터베이스의 각 필드는 Field클래스의 인스턴스로 표현합니다. 이 작업을 통해 각 필드가 어떤 자료형을 가질 수 있는지를 Django에게 말해줍니다.

• CharField : 문자(character)형 타입 필드

• DateTimeField : 날짜와 시간형 타입 필드

• IntegerField : 정수형 타입 필드

• AutoField : 자동증가하는 정수형 타입 필드, 주로 pk를 저장할 때 사용하지만 django 내부적으로 id라는 컬럼을 자동생성하므로, A model can't have more than one AutoField 에러가 발생할 수 있습니다. 이를 방지하려면 id를 생성하지 않고 해당 필드가 PK가 되도록 primary_key=True옵션을 추가해야 합니다.

  ex) category_id = models.AutoField(primary_key=True)

이 외의 필드 타입에 대한 내용은 다음 링크를 참고하여 사용하도록 합니다.

ForeignKey 클래스를 통해 테이블 간의 관계를 설정할 수도 있습니다. Django 는 다-대-일(many-to-one), 다-대-다(many-to-many), 일-대-일(one-to-one) 과 같은 모든 일반 데이터베이스의 관계들를 지원합니다.

모델 활성화하기

이 모델을 통해 Django에서는 다음과 같은 작업을 진행합니다.

• 이 앱을 위한 데이터베이스 스키마 생성(CREATE TABLE 문)
• TestBook과 TestBookCategory 객체에 접근하기 위한 Python 데이터베이스 접근 API를 생성

위 작업을 하기 위해 먼저 test_project프로젝트 내 settings.py파일의 INSTALLED_APPS에 앱의 구성 클래스에 대한 참조를 추가하여 test_app앱이 설치되어 있다는 것을 알려줍니다. 이 구성 클래스는 앱이름 + Config이라는 이름으로 생성되어 있으며, test_app/apps.py파일 내에 존재합니다. 이 내용을 바탕으로 INSTALLED_APPS에 구성 클래스를 추가합니다. (이전 포스팅에서 test_app 패키지를 통으로 넣어줬다면 별도로 작업하지 않아도 됩니다.)

INSTALLED_APPS = [
    "test_app.apps.TestAppConfig",
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
]

Django에 test_app앱이 포함된 것을 알려줬다면 다음 명령을 실행합니다.

$ python manage.py makemigrations test_app

makemigrations 을 실행하게 되면 모델을 생성 혹은 변경시킨 사실과 이 변경사항을 migration으로 저장시키고 싶다는 것을 Django에게 알려주게 됩니다.

Migration은 Django가 모델(즉, 데이터베이스 스키마)의 변경사항을 디스크에 저장하는 방법입니다. test_app/migrations/0001_initial.py파일에 변경된 새 모델에 대한 migration을 읽어 볼 수 있습니다. 이 파일을 직접 수정할 수 있도록 설계가 되어 있어 Django의 변경점을 수동으로 수정할 수도 있습니다.

다음으로 sqlmigrate 명령을 통해 Migration이 내부적으로 어떤 SQL 문장을 실행하는지 살펴 볼 수 있습니다.

$ python manage.py sqlmigrate test_app 0001

저의 경우에는 MySQL을 연동하여 다음과 같이 쿼리가 표시되며 이 내용은 연동하는 DB마다 다를 수 있습니다.

sqlmigrate은 실제로 DB에 마이그레이션이 되지 않고 화면에 출력해줍니다. 단지 마이그레이션에 사용할 SQL문을 보여주는 것이며, 내가 작성한 테이블 모델이 어떻게 db에 마이그레이션이 될지 확인하는 용도로 유용하게 사용할 수 있습니다.

--
-- Create model TestBookCategory
--
CREATE TABLE `core_testbookcategory` (`id` bigint AUTO_INCREMENT NOT NULL PRIMARY KEY, `categoryName` varchar(20) NOT NULL);
--
-- Create model TestBook
--
CREATE TABLE `core_testbook` (`id` bigint AUTO_INCREMENT NOT NULL PRIMARY KEY, `title` varchar(200) NOT NULL, `price` integer NOT NULL, `reg_datetime` datetime(6) NOT NULL, `category_id` bigint NULL);
ALTER TABLE `core_testbook` ADD CONSTRAINT `core_testbook_category_id_11be1c0d_fk_core_testbookcategory_id` FOREIGN KEY (`category_id`) REFERENCES `core_testbookcategory` (`id`);

sqlmigrate로 출력된 쿼리를 실제로 적용하려면 migrate 명령을 사용합니다.

$ python manage.py migrate

migrate 명령은 아직 적용되지 않은 마이그레이션을 모두 수집해서 실행하며, 이 과정을 통해 모델에서의 변경 사항들과 데이터베이스의 스키마의 동기화가 이루어집니다.

django의 이 강력한 기능은 DB나 테이블을 거의 직접 다루지 않고도 모델을 생성하고 반복적인 변경도 가능하게 해줍니다. 게다가 동작 중인 데이터베이스를 자료 손실 없이 업그레이드하는데 최적화 되어 있습니다.

이 일련의 작업들이 복잡해 보일 수도 있지만 이 단계만 기억하면 됩니다.

1. models.py 에서 모델을 변경합니다.
2. makemigrations을 통해 이 변경사항에 대한 마이그레이션을 생성합니다.
3. migrate명령을 통해 변경사항을 데이터베이스에 적용합니다.

지난 번 포스팅에 이어 API를 만들어 테이블에 데이터를 삽입(insert)을 진행하도록 하겠습니다.

test_app/views.py에 다음 코드를 추가합니다.

...
from rest_framework import status



@api_view(['POST'])
def setTestMember(request):
    reqData = request.data
    serializer = TestMemberSerializer(data=reqData)
    if serializer.is_valid():
        serializer.save()
        return Response(serializer.data)
    return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

...

@api_view(['POST']) 어노테이션 지정하여 해당 view에 접근했을 때 POST 메소드로 데이터를 전송하는 화면이 뜨도록 합니다. 그리고 데이터를 입력하여 POST버튼을 눌러 데이터가 전달되면 is_valid()함수로 데이터의 유효성을 확인한 뒤 성공하면 save()함수로 DB에 삽입하고, 유효하지 않으면 400 Bad Request라는 상태코드를 넘겨주도록 했습니다. 이번에는 실패시 응답에 200 OK가 아닌 HttpStatusCode를 넘겨주기 위해 status모듈을 import 시켜주었습니다.

그리고 test_app/urls.py에 해당 view가 호출될 url를 추가시켜 줍니다.

...
urlpatterns = [
    path("member", views.setTestMember, name="setMembers"),
...
]
...

이제 서버를 기동시켜 브라우저에서 http://127.0.0.1:8000/test/member/로 접근해봅시다. 정상적으로 작성됐다면 다음과 같은 화면이 뜨게 됩니다. 해당 페이지 하단의 입력 항목들을 채워 넣고 POST 버튼을 누릅니다. Media type : application/json Content :

{
  "name" : "peter",
  "age" : 17,
  "created_at" : "2023-07-09 23:21:44"
}

요청 성공 위 그림과 같이 성공응답과 삽입된 데이터 내용이 표시되며, 실제 DB에서 조회시에도 데이터가 삽입된 것을 확인할 수 있습니다.

요청 실패 요청 실패시에는 코드에서 작성한 것과 같이 400 Bad Request 상태코드가 전달되고, 어떤 부분에서 실패가 났는지에 대한 내용이 표시됩니다.

테이블 생성하기

Mysql 워크벤치를 통해서 사용할 테이블을 하나 생성합니다.

CREATE TABLE testdb.test_member(
    id INT NOT NULL AUTO_INCREMENT,
    name VARCHAR(255) NOT NULL,
    age INT NOT NULL,
    created_at DATETIME NOT NULL DEFAULT NOW(), 
    updated_at DATETIME NULL DEFAULT NULL ON UPDATE NOW(),
    PRIMARY KEY (id)
);

확인을 위해 생성된 테이블에 데이터도 몇개 삽입해줍니다.

INSERT INTO `testdb`.`test_member`
(`name`,
`age`)
VALUES
('harry', 34),
('john', 42),
('rachel', 24);

모델 생성하기

모델이란 부가적인 메타데이터를 가진 데이터베이스의 구조(layout)를 말합니다. Django의 models.py로 테이블을 생성할 수 있지만 반대로 기존에 존재하는 DB의 테이블을 가져올 수도 있습니다. 이미 존재하는 테이블을 model.py로 만드려면 아래의 명령을 프롬프트에 입력합니다.

$ python manage.py inspectdb > models.py

이렇게 입력하면 명령을 입력한 디렉토리에 default로 연결된 db에 대한 모델파일인 models.py 파일이 만들어집니다. 만약 default db외에 별도의 db를 연결한 상태라면 아래의 명령으로 해당 db의 모델파일을 생성할 수 있습니다.

$ python manage.py inspectdb --datebase DB명 > models.py

만들어진 models.py를 test_app/ 디렉토리 하위에 넣어서 덮어쓰기를 합니다.

특정 테이블의 데이터 모두 읽어 들이기

데이터를 읽어들이기 전에 Django의 API 기능을 사용하기 위해 아래의 명령으로 패키지를 설치합니다.

$ pip install djangorestframework

설치한 패키지를 사용하기 위해 settings.py파일을 수정해보겠습니다. rest_framework와 우리가 만든 앱인 test_app도 같이 포함시켜 INSTALLED_APPS 항목에 추가해 줍니다.

...
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',

    'test_app',
    'rest_framework',
]
...

다음으로 모델을 직렬화하기 위해 test_app/ 디렉토리 하위에 serializer.py 파일을 생성하고 다음과 같은 코드를 작성합니다.

from rest_framework.serializers import ModelSerializer
from models import TestMember

class TestMemberSerializer(ModelSerializer):
    class Meta:
        model = TestMember
        fields = '__all__'

직렬화란? 객체를 바이트 스트림으로 변환하는 것, 즉 객체에 저장된 데이터 스트림에 쓰기 위해 연속적인 직렬 데이터로 변환하는 것이다. 쉬운 예로 DB에서 불러온 데이터를 json으로 보여주기 위해 가공하는 부분으로 이해하시면 될 것 같습니다.

코드에 대해 간략히 설명하자면, 아까 설치했던 rest_framework 패키지내의 ModelSerializer와 inspectdb 명령을 통해 생성되었던 models.py 내의 TestMember 테이블 클래스을 가져와서 test_member 테이블의 데이터를 직렬화하여 TestMember 클래스로 변환해주는TestMemberSerializer 클래스를 생성하였습니다. 이제 TestMember 클래스 오브젝트로 db데이터를 읽어오고, TestMemberSerializer로 사용자가 볼 수 있게 데이터를 변환할 수 있게 되었습니다.

확인을 위해 인덱스 페이지를 수정해 봅시다. views.py파일을 열어 다음과 같이 수정합니다.

from .models import TestMember
from .serializer  import TestMemberSerializer
from django.http import HttpResponse

def index(request):
    datas = TestMember.objects.all()
    serializer = TestMemberSerializer(datas, many=True)

    return HttpResponse(serializer.data)

서버를 실행하여 인덱스 페이지를 열어봅니다.

$ python manage.py runserver

다음과 같은 내용이 노출된다면 DB에서 데이터를 정상적으로 가져온 것입니다.

rest_framework 패키지를 설치한 김에 API 형태로도 내용을 노출해봅시다. views.py를 다음과 같이 작성합니다.

from rest_framework.response import Response
from rest_framework.decorators import api_view
from .models import TestMember
from .serializer  import TestMemberSerializer
from django.http import HttpResponse

@api_view(['GET'])
def getTestMembers(request):
    datas = TestMember.objects.all()
    serializer = TestMemberSerializer(datas, many=True)
    return Response(serializer.data)

@api_view(['GET'])
def getTestMember(request, name):
    data = TestMember.objects.get(name=name)
    serializer = TestMemberSerializer(data, many=False)
    return Response(serializer.data)

def index(request):
    datas = TestMember.objects.all()
    serializer = TestMemberSerializer(datas, many=True)

    return HttpResponse(serializer.data)

그리고 test_app/내의 urls.py 파일에 추가한 api의 url를 등록해줍니다.

from django.urls import path
from . import views

urlpatterns = [
    path("members/", views.getTestMembers, name="getMembers"),
    path("member/<str:name>", views.getTestMember, name="getMember"),
    path("hello/", views.index, name="index"),
]

/members API는 테이블 데이터 전체조회를 하는 API이고, /member/<str:name> API는 테이블에서 해당되는 이름의 데이터만 검색하는 API입니다. <str:name>은 member/ 뒤에 붙는 Path Parameter로 검색할 이름을 저장하는 String 타입의 변수입니다.

예를 들어 'harry'라는 이름의 멤버를 검색하려면 /member/harry로 url을 호출하면 harry에 대한 정보만 검색이 됩니다.

작성을 마치고 브라우저를 통해 호출해보면 아래 그림과 같이 정상적으로 데이터를 읽어올 수 있습니다.

데이터베이스를 연동하려면 test_project/settings.py 파일을 수정해야 합니다. 이 파일은 Django 설정을 모듈 변수로 표현한 Python 모듈입니다. 아래 코드와 같이 디폴트로 SQLite를 사용하도록 구성되어 있습니다.

...

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

실습용으로는 SQLite를 그대로 사용해도 무방하지만, 실제 프로젝트를 시작할 때에는 PostgreSQL, MariaDB, MySQL등의 좀 더 확장성 있는 데이터베이스를 사용하는 것이 좋습니다. 다른 데이터베이스를 사용해보고 싶다면 데이터베이스에 맞는 각 데이터베이스 바인딩을 설치하고, settings.py의 DATABASES 'default' 항목의 값을 다음의 키 값으로 바꿔줍니다.

• ENGINE : 'django.db.backends.sqlite3', 'django.db.backends.postgresql', 'django.db.backends.mysql', 또는 'django.db.backends.oracle'. 그외에 서드파티 백엔드 참조
• NAME : 데이터베이스의 이름으로 SQLite를 사용하는 경우에는 컴퓨터의 파일을 데이터베이스로 사용하므로, 이 경우에는 파일 이름을 포함한 해당 파일의 전체 절대 경로로 입력해줘야 합니다.

SQLite 외의 DB를 사용하는 경우 아래 예시와 같이 USER, PASSWORD, HOST와 같은 추가 설정이 반드시 필요합니다. 자세한 내용은 해당 페이지를 참고바랍니다.

# postgresql 사용할 경우
DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.postgresql",
        "NAME": "mydatabase",
        "USER": "mydatabaseuser",
        "PASSWORD": "mypassword",
        "HOST": "127.0.0.1",
        "PORT": "5432",
    }
}

스키마 생성 SQLite를 사용한다면 필요할 때마다 자동으로 데이터베이스 파일이 생성됩니다. 하지만 SQLite 이외의 데이터베이스를 사용한다면 별도로 데이터베이스를 미리 생성해 놓아야 합니다. 사용하는 데이터베이스에 접속하여 아래 명령으로 데이터베이스를 생성할 수 있습니다.

CREATE DATABASE database_name;

또한 test_project/settings.py에 설정된 데이터베이스 사용자가 create database권한이 있는지 확인해야 합니다. 권한이 있어야 테스트 데이터베이스를 자동으로 생성할 수 있습니다.

필자는 MySQL을 연동하여 개발을 진행해 보겠습니다. 먼저 MySQL 워크벤치 등의 프로그램을 통해 DB에 접속한 후 사용할 데이터베이스를 생성해 줍니다.

CREATE SCHEMA `testdb` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_bin ;

다음으로 MySQL DB와 Django를 연결하려면 mysqlclient가 필요합니다. 다음 명령으로 mysqlclient를 설치해 줍니다.

$ pip install mysqlclient

Collecting mysqlclient
 Downloading mysqlclient-2.2.0.tar.gz (89 kB)
    >━━━━━━━━━━━━━━━━━━━━━━━━━━━━━>━━━━━━━━━━━ 89.5/89.5 kB 1.6 MB/s eta >0:00:00
 Installing build dependencies ... done
 Getting requirements to build wheel ... error
 error: subprocess-exited-with-error

 × Getting requirements to build wheel did not > run successfully.
 │ exit code: 1
 ╰─> [24 lines of output]
     /bin/sh: 1: pkg-config: not found
     /bin/sh: 1: pkg-config: not found
     Trying pkg-config --exists mysqlclient
     Command 'pkg-config --exists mysqlclient' > returned non-zero exit status 127.
     Trying pkg-config --exists mariadb
     Command 'pkg-config --exists mariadb' returned non-zero exit status 127.

만약 이런 에러가 발생했다면 필요한 패키지들이 없어서 발생하는 것이므로 다음 패키지들을 설치해 줍니다.

$ sudo apt-get install python3-dev libmysqlclient-dev build-essential pkg-config -y

mysqlclient 설치가 완료되었다면 settings.py를 수정해줍니다.

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'testdb',
        'USER': 'root',
        'PASSWORD': 'xxxx',
        'HOST': 'localhost',
        'PORT': '3306',
    }
}

수정을 마치고 연결이 잘 되는지 Django 서버를 실행해 봅시다.

$ python manage.py runserver

❯ python manage.py runserver
 Watching for file changes with StatReloader
 Performing system checks...

System check identified no issues (0 silenced).

You have 18 unapplied migration(s). Your project may not work properly until you apply the migrations for app(s): admin, auth, contenttypes, sessions.
Run 'python manage.py migrate' to apply them.
July 05, 2023 - 22:52:45
Django version 4.2.2, using settings 'test_project.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

DB연결이 제대로 되지 않으면 runserver 명령어 실행시 에러가 발생하므로, 위와 같은 프롬프트가 뜨고 브라우저에서http://127.0.0.1:8000/로 접근 시 로켓 이미지가 표시된다면 정상적으로 연결이 된 것입니다.

데이터베이스 정상 연동이 확인되었으므로 계속해서 migrate 명령으로 DB 초기화 작업을 시켜줍니다.

$ python manage.py migrate

migrate 명령은 INSTALLED_APPS 설정을 탐색하여, test_app/settings.py의 데이터베이스의 설정과 app 과 함께 제공되는 database migrations에 따라, 필요한 데이터베이스 테이블을 생성합니다.

INSTALLED_APPS는 현재 Django 인스턴스에서 활성화된 모든 Django 앱(어플리케이션)의 이름을 담고 있습니다. 앱들은 다수의 프로젝트에서 사용될 수 있고, 다른 프로젝트에서 쉽게 사용될 수 있도록 패키징하여 배포할 수 있습니다. 현재 생성된 Django 프로젝트는 여러 기본 제공되는 앱이 등록되어 있으나 해당 앱들이 불필요하다면 migrate 명령을 실행하기 전에 settings.py내의 INSTALLED_APPS에서 제거할 앱을 주석처리하거나 삭제하시면 됩니다.

migrate 작업 완료 후 다시 서버를 실행하여 정상 연결 여부를 확인합니다. 마찬가지로 에러가 나지 않고 브라우저로 접속시에 로켓 이미지가 노출된다면 정상적으로 연결된 것입니다.

추가로 MySQL 워크벤치 등으로 MySQL DB에 접근하여 기본구성에 필요한 테이블들이 잘 생성되어 있는지 확인하실 수도 있습니다.

다음 포스팅에서는 실제로 테이블에 데이터를 읽고 쓰는 방법에 대해 알아보겠습니다.

지난 번 포스팅에서 Django 프로젝트 생성을 통해 작업을 시작하기 위한 환경 세팅이 완료되었습니다. manage.py 파일이 존재하는 디렉토리에서 다음 명령을 통해 해당 프로젝트 내에 작업할 앱을 하나 생성해봅시다.

$ python manage.py startapp test_app

프로젝트 vs 앱 프로젝트 : 특정 웹 사이트에 대한 구성 및 앱의 모음. 한 프로젝트에 여러 개의 앱이 포함될 수 있음. 앱 : 블로그 시스템, 공개 기록 데이터베이스 또는 소규모 의견조사 앱과 같은 작업을 수행하는 웹 애플리케이션. 앱은 여러 프로젝트에 있을 수 있음.

생성된 앱은 아래와 같은 디렉터리 구조를 가집니다.

test_app/
    __init__.py
    admin.py
    apps.py
    migrations/
        __init__.py
    models.py
    tests.py
    views.py

뷰 작성하기

test_app/views.py를 수정하여 가장 간단한 형태를 뷰를 한번 작성해 봅시다.

from django.http import HttpResponse

def index(request):
    return HttpResponse("Hello, world!")

뷰를 실제로 호출하여 화면에 띄우려면 이와 연결된 URL이 있어야 하는데, 이것은 URLconf를 통해 설정할 수 있습니다. test_app 디렉토리에서 URLconf를 생성하기 위해 urls.py라는 파일을 만듭니다. 여기까지 작업하면 앱 디렉토리의 구조는 아래와 같을 것입니다.

test_app/
    __init__.py
    admin.py
    apps.py
    migrations/
        __init__.py
    models.py
    tests.py
    urls.py
    views.py

urls.py파일에는 다음과 같은 코드를 입력하여 라우팅할 path를 구성합니다.

from django.urls import path
from . import views

urlpatterns = [
    path("world/", views.index, name="index"),
]

path()

path() 함수의 파라미터는 아래와 같이 명시적으로도 작성할 수 있습니다.

from django.urls import path
from . import views

urlpatterns = [
path(route="world/", view=views.index, kwargs=None, name="index"),
]

각 파라미터를 하나하나 뜯어보면 다음과 같습니다. route : URL 패턴을 가진 문자열입니다. 요청이 처리될 때, Django 는 urlpatterns 의 첫 번째 패턴부터 시작하여, 일치하는 패턴을 찾을 때 까지 요청된 URL 을 각 패턴과 리스트의 순서대로 비교합니다. view : Django가 일치하는 URL 패턴을 찾으면, 첫번째 인수에는 HttpRequest객체가 담기고 경로로 부터 '캡처된' 값을 kwargs 인수로 하여 view에 지정한 함수를 호출합니다. kwargs : 해당 경로로 들어왔을 때 호출되는 함수에 전달되는 임의의 키워드 인수들. 목표한 view 에 dict 형태으로 전달됩니다. name : 템플릿을 포함한 Django 어디에서나 명확하게 참조할 수 있도록 지정하는 이름입니다.

다음으로 test_project/url.py 파일을 열고, 아래 코드로 최상위 URLconf에서 test_app.urls 모듈을 바라보게 설정합니다.

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

urlpatterns = [
    path("hello/", include("test_app.urls")),
    path("admin/", admin.site.urls),
]

include()

include() 함수는 다른 URLconf들을 참조할 수 있도록 도와주는 함수 입니다. Django가 include() 함수를 만나게 되면 URL의 그 시점까지 일치하는 부분을 잘라내고, 남은 문자열 부분을 후속 처리를 위해 include된 URLconf로 전달합니다. admin.site.urls를 제외하고 다른 URL 패털을 포함할 때마다 항상 include()를 사용해야 합니다.

이제 index 뷰가 URLconf에 연결되었으니 아래 명령으로 서버를 구동하여 정상적으로 작동하는지 확인해 봅시다.

$ python manage.py runserver

지금까지 잘 따라왔다면 브라우저에서 http://localhost:8000/hello/world를 입력하면, views.py 내의 index()함수가 호출되어 "hello, world"라는 문구가 노출되게 됩니다.

Django 프로젝트는 django-admin 명령을 통해 자동 생성할 수 있습니다.

$ django-admin startproject myproject

django-admin은 Django 프로젝트의 관리 작업을 위한 커맨드 라인 유틸리티입니다. 자세한 내용은 기회가 되면 다뤄보겠습니다

돌아와서 위 명령을 통해 현재 디렉토리에서 myproject라는 디렉토리가 생성되며 startproject를 통해 생성된 프로젝트 구조는 다음과 같습니다.

    manage.py
    myproject/
        __init__.py
        settings.py
        urls.py
        asgi.py
        wsgi.py

• manage.py : 각 Django 프로젝트에서 자동 생성되는 파일. django-admin과 동일한 작업을 수행하지만 작업할 프로젝트의 setting.py파일을 DJANGO_SETTING_MODULE 환경변수로 세팅하는 역할도 합니다. 일반적으로 단일 Django 프로젝트를 작업할 경우에는 django-admin보다 manage.py 파일을 사용하는 것이 더 쉽습니다.
• myproject/ 디렉토리 내부에는 프로젝트를 위한 실제 Python 패키지들이 저장됩니다. 이 디렉토리 내의 이름을 이용하여, 프로젝트의 어디서나 Python 패키지들을 임포트 할 수 있습니다.
• myproject/_init_.py : 이 파일이 포함된 디렉토리를 패키지로 처리하도록 하기 위해 필요한 파일입니다. _init_.py 파일은 빈 파일일 수 있지만 패키지에 대한 초기화 코드를 실행하거나 __all__변수를 설정할 수도 있습니다.
• myproject/settings.py : setting.py파일에는 Django 설치의 모든 구성이 포함되어 있습니다.
• myproject/urls.py : Django 프로젝트의 URL 선언할 때 사용합니다.
• myproject/asgi.py : 현재 프로젝트를 서비스하기 위한 ASGI-호환 웹 서버의 엔드포인트입니다. ASGI(Asynchronous Server Gateway Interface)란 비동기 웹서버와 애플리케이션을 위한 파이썬 표준 인터페이스입니다.
• myproject/wsgi.py : 현재 프로젝트를 서비스하기 위한 WSGI-호환 웹 서버의 엔드포인트입니다. WSGI(Web Server Gateway Interface)란 동기 웹서버와 애플리케이션이 통신하기 위한 파이썬 표준 인터페이스입니다.

ASGI와 WSGI에 대한 설명은 해당 아티클를 참고하길 바랍니다.

서버 구동하기

myproject 디렉토리에서 아래 명령어를 통해 서버를 구동할 수 있습니다.

$ python manage.py runserver

구동에 성공하면 명령줄에서 다음과 같은 출력을 보게 됩니다.

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

System check identified no issues (0 silenced).

You have unapplied migrations; your app may not work properly until they are applied.
Run 'python manage.py migrate' to apply them.

July 03, 2023 - 14:03:22
Django version 4.2.2, using settings 'myproject.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

참고 경고문구 You have unapplied migrations~ 부분은 아직 데이터베이스 적용되지 않은 변경사항들이 있을 때 출력되는 문구로 현재는 무시해도 됩니다.

그리고 명령줄에 출력된 url을 웹브라우저 등에서 접속하면 해당 로켓 그림이 나오는 페이지가 뜨게 됩니다.

포트 변경하기

기본적으로, runserver 명령은 내부 IP의 8000번 포트로 개발서버를 띄우게 됩니다. 포트를 변경하려면 아래와 같이 명령어에 인수를 추가로 전달해주시면 됩니다.

$ python manage.py runserver 8080

서버의 IP도 다음과 같이 변경할 수 있습니다.

$ python manage.py runserver 0.0.0.0:8000

python으로 만들어진 무료 오픈소스 웹 애플리케이션 프레임워크

설치하기

1. 가상환경 세팅

각 어플리케이션 간의 설치하는 패키지 버전에 따른 Conflict를 방지하기 위해서 어플리케이션 별로 독립된 가상환경을 세팅을 진행합니다.

1) 프로젝트 디렉토리 생성

    $ mkdir django_webapp
    $ cd django_webapp

2) 가상환경 생성

    $ python3 -m venv myvenv

여기에서 myvenv는 가상환경의 이름입니다. 이름은 소문자에 공백이 없도록 작성해야 합니다.

NOTE : 우분투 환경에서 다음과 같은 에러가 발생할 수 있습니다.

The virtual environment was not created successfully because ensurepip is not available.  On Debian/Ubuntu systems, you need to install the python3-venv package using the following command.
    apt install python3-venv
You may need to use sudo with that command.  After installing the python3-venv package, recreate your virtual environment.

지시에 따라 아래 명령어를 입력하여 패키지를 설치해 줍니다.

$ sudo apt install python3-venv

3) 가상환경 활성화

앞의 명령어로 생성된 가상환경은 다음 명령어를 통해 활성화할 수 있습니다.

$ source myvenv/bin/activate

NOTE : source를 사용할 수 없는 경우 아래 명령어로 활성화할 수 있습니다.

$ . myvenv/bin/activate

콘솔 프롬프트 앞에 (myvenv)접두어가 붙어있는 것이 확인된다면 virtualenv가 정상적으로 활성화가 된 상태입니다.

2. Django 설치

1) pip 최신버전으로 업그레이드

(myvenv) ~$ python3 -m pip install --upgrade pip

2) Django 패키지 설치

$ python -m pip install Django

3. 설치 확인

아래의 명령어로 버전을 확인할 수 있습니다. 버전이 정상적으로 출력된다면 설치가 완료된 것입니다.

$ python -m django --version
4.2.3

위 명령어 외에도 python 프롬프트로 들어가서 다음 코드를 실행해보면 설치된 버전이 출력됩니다.

>>> import django
>>> print(django.get_version())
4.2.3

pom.xml

1. resource 필터링 활성화를 통해 application.properties 리소스 파일의 속성을 필터링(교체)

    <resources>
        <resource>
            <filtering>true</filtering>
            <directory>src/main/resources</directory>
            <includes>
                <include>application.properties</include>
            </includes>
        </resource>
    </resources>

2. application.properties 파일에서 maven 프로퍼티를 ${} 형태로 주입받을 수 있도록 설정

   1. spring-boot-start-parent에서는 @property@로 프로터피를 주입받게 재정의되어 있으나useDefaultDelimiters : true로 주면 ${property}로 주입받을 수 있다.

      <build>
      ...
       <plugins>
         ...
           <plugin>
               <groupId>org.apache.maven.plugins</groupId>
               <artifactId>maven-resources-plugin</artifactId>
               <version>2.7</version>
               <configuration>
                   <useDefaultDelimiters>true</useDefaultDelimiters>
               </configuration>
           </plugin>
       </plugins>
      </build>

application.properties

1. 아래와 같이 pom.xml에서 가져올 프로퍼티를 지정한다.

  application.name=${project.artifactId}
  build.version=${project.version}

❯ systemctl start mongod
System has not been booted with systemd as init system (PID 1). Can't operate.
Failed to connect to bus: Host is down

찾아보니 wsl2에서는 systemd를 지원하지 않기 때문에 공식적으로는 systemctl 명령어를 사용할 수 없다고 한다. 대신 service 명령은 지원하기 때문에 service 명령으로 실행해보라고 한다.

service 라는 명령어는 /etc/init.d에 해당 파일이 존재할 때 사용할 수 있는 명령어 이다.

❯ sudo service mongod start
mongod: unrecognized service

apt-get으로 mongodb를 설치했을때 /etc/init.d에 mongod파일이 생성되지 않는 듯 하다.

수동으로 /etc/init.d에 mongod 파일을 만들어주자.

cd /etc/init.d
sudo touch mongod
sudo chmod 755 mongod

https://github.com/mongodb/mongo/blob/master/debian/init.d

찾아보니 해당 링크의 내용으로 mongod 파일을 만들면 되는 듯하다.

mongod 파일에 해당 내용을 붙여넣기하고 다시 실행해보았다.

❯ sudo service mongod start
 * Starting database mongod                                                                             [ OK ]
❯ ps -ef | grep mongod
mongodb  23520 17530  4 14:19 ?        00:00:00 /usr/bin/mongod --config /etc/mongod.conf

정상적으로 뜨는 것 같다.

해당 에러가 발생하는 경우는 해당 서버의 인증서가 없어서 저장소에 릴리즈된 파일들을 읽어오지 못하는 경우이다.

1. 아래 명령어로 해당 서버의 인증서를 파일로 읽어온다.

   openssl s_client -connect apt.kubernetes.io:443 | tee cert_file

2. 파일의 BEGIN CERTIFICATE 부분부터 END CERTIFICATE까지가 인증서 부분이기 때문에 해당 부분만 남기고 나머지는 지우고 파일을 저장한다.

3. 아래 명령어로 제대로 추출되었는지 확인한다.

   openssl x509 -inform PEM -text -in cert_file

4. 해당 인증서의 내용을 신뢰하는 인증 기관 목록(CA List; Certificate Authority List)에 추가한다.

   cat cert_file >> /etc/ssl/certs/ca-certificates.crt