Jak dockerować aplikację Django na Linuksie

W tym samouczku pokażę, jak skonfigurować środowisko Docker dla projektu Django, gdy jest on jeszcze w fazie rozwoju. Chociaż używam Ubuntu 18.04, kroki pozostają takie same dla każdej dystrybucji Linuksa, z wyjątkiem instalacji Dockera i docker-compose.

W typowym projekcie tworzenia oprogramowania zazwyczaj mamy proces rozwoju, który zazwyczaj zaczyna się od założeń dewelopera, przechodzi przez system kontroli wersji (VCS), aż do produkcji. Postaramy się trzymać zasad, abyś zrozumiał, gdzie wchodzą w grę poszczególne narzędzia DevOps.

DevOps polega na eliminowaniu starego stwierdzenia: „Ale u mnie na laptopie działa!”. Konteneryzacja za pomocą Docker tworzy środowisko produkcyjne dla Twojej aplikacji, dzięki czemu można ją wdrożyć wszędzie – stwórz raz, wdrażaj wszędzie!

1) Zainstaluj silnik Docker

Na swoim serwerze/komputerze stacjonarnym musisz mieć zainstalowany silnik wykonawczy Docker. Nasze przewodniki instalacji Dockera powinny okazać się bardzo pomocne.

Jak zainstalować Docker na CentOS/Debian/Ubuntu

2) Konfiguracja środowiska

Utworzyłem repozytorium GitHub dla tego projektu o nazwie django-docker-dev-app. Śmiało możesz je rozwidlić lub sklonować/pobrać.

Najpierw utwórz folder, w którym będzie przechowywany Twój projekt. Mój folder roboczy nazywa się django-docker-dev-app. Przejdź do tego folderu, a następnie otwórz go w swoim IDE.

Plik Docker

W środowisku konteneryzowanym wszystkie aplikacje działają w kontenerze. Same kontenery składają się z kilku obrazów. Możesz stworzyć własny obraz lub użyć innych obrazów z Docker Hub. Dockerfile to tekstowy dokument Docker, który Docker odczytuje, aby automatycznie tworzyć/budować obraz. Nasz Dockerfile będzie zawierał listę wszystkich zależności wymaganych przez nasz projekt.

Utwórz plik o nazwie Dockerfile.

nano Dockerfile

W polu typu pliku wpisz następujące:

#base image
FROM python:3.9-alpine

#maintainer
LABEL Author="CodeGenes"

# The enviroment variable ensures that the python output is set straight
# to the terminal with out buffering it first
ENV PYTHONBUFFERED 1

#copy requirements file to image 
COPY ./requirements.txt /requirements.txt

#let pip install required packages
RUN pip install -r requirements.txt

#directory to store app source code
RUN mkdir /app

#switch to /app directory so that everything runs from here
WORKDIR /app

#copy the app code to image working directory
COPY ./app /app

#create user to run the app(it is not recommended to use root)
#we create user called user with -D -> meaning no need for home directory
RUN adduser -D user

#switch from root to user to run our app
USER user

Utwórz plik requirements.txt i dodaj wymagania swojego projektu.

Django
djangorestframework

Utwórz folder app, który będzie przechowywał kod źródłowy. Teraz jesteśmy gotowi, aby zbudować nasz obraz!

mkdir app

Otwórz terminal w swoim projekcie i wpisz następujące polecenie, aby zbudować nasz obraz:

 docker build .

Na końcu informuje Dockera, aby sprawdził obecność pliku Dockerfile w tym samym katalogu. Gdyby plik znajdował się w innym miejscu, podalibyśmy ścieżkę do tego pliku. Docker następnie pobierze niezbędne obrazy z Docker Hub, aby utworzyć Twój obraz.

Używanie Docker Compose

Z dokumentacji Dockera: Compose to narzędzie do definiowania i uruchamiania aplikacji Docker z wieloma kontenerami. Dzięki Compose używasz pliku YAML do konfigurowania usług swojej aplikacji. Następnie, za pomocą jednego polecenia, tworzysz i uruchamiasz wszystkie usługi z konfiguracji.

Zainstaluj Docker Compose na Linuksie

Ponieważ nasz projekt w przyszłości będzie wymagał wielu usług, lepiej jest stworzyć środowisko wielokontenerowe. Na przykład możemy potrzebować kontenera do hostowania frontendu, innego do bazy danych i kolejnego do hostowania backendu, gdy przejdziemy na architekturę mikroserwisów. Stworzymy plik docker-compose, który zdefiniuje różne usługi i kontenery, których będzie wymagał nasz projekt.

Utwórz plik o nazwie docker-compose.yml

version: "3"
services:
  ddda:
    build:
      context: .
    ports:
      - "8000:8000"
    volumes:
      - ./app:/app
    command: >
      sh -c "python manage.py runserver 0.0.0.0:8000"

Zwróć uwagę na format pliku YAML!!! Mamy jedną usługę nazwaną ddda (Django Docker Dev App).

Jesteśmy teraz gotowi, aby zbudować naszą usługę:

docker-compose build

Po udanym zbudowaniu zobaczysz: Pomyślnie oznaczono djangodockerdevapp_ddda:latest

Oznacza to, że nasz obraz nosi nazwę djangodockerdevapp_ddda:latest, a nasza usługa nazywa się ddda

Zauważ teraz, że jeszcze nie stworzyliśmy naszego projektu Django! Jeśli pomyślnie wykonałeś powyższe kroki, gratulacje, ustawiłeś środowisko Dockera dla swojego projektu! Następnie rozpocznij rozwój, wykonując następujące czynności:

Utwórz projekt Django:

 docker-compose run ddda sh -c “django-admin.py startproject app .”

Aby uruchomić swój kontener:

docker-compose up

Następnie odwiedź http://localhost:8000/

Wykonaj migracje

$ docker-compose exec ddda python manage.py migrate

Od teraz będziesz uruchamiać polecenia Django podobnie jak powyższe polecenie, dodając swoje polecenie po nazwie usługi ddda.

To wszystko na razie. Wiem, że to proste i jest wiele funkcji, których nie omówiliśmy, jak np. baza danych, ale to jest początek!

Projekt jest dostępny na GitHubie tutaj.

Więcej o Dockerze:

Eksport i import obrazów/kontenerów Dockera
Zainstaluj rejestr obrazów Docker Harbor na CentOS/Debian/Ubuntu
Jak uruchamiać lokalne klastry Kubernetes w Dockerze