GNU/Linux >> Belajar Linux >  >> Panels >> Docker

Cara Membuat Wadah Aplikasi Django Docker

Docker memungkinkan Anda untuk mengemas aplikasi Anda dengan cara yang menyederhanakan kolaborasi dan penerapan. Tetapi jika Anda baru mengenal Docker dan bertanya-tanya bagaimana cara membuat wadah Django Docker untuk aplikasi web Anda, Anda siap menerimanya!

Dalam tutorial ini, Anda akan belajar menjadi master Anda sendiri dalam membangun image dan wadah Docker untuk aplikasi Django Anda.

Bersiaplah dan mulai kemas!

Prasyarat

Tutorial ini akan menjadi demonstrasi langsung. Jika Anda ingin mengikuti, pastikan Anda memiliki yang berikut:

  • Docker dan Docker Compose diinstal.
  • Mesin Linux – Tutorial ini menggunakan Ubuntu 20.04.3 LTS.
  • Python terinstal – Tutorial ini menggunakan Python 3.8.12.

Membuat API Django dan Menghubungkan ke PostgreSQL

Sebelum membuat wadah aplikasi Django Docker, Anda memerlukan aplikasi untuk wadah terlebih dahulu. Anda akan membangun API resep dan menghubungkannya ke PostgreSQL, yang datang dengan Django secara default.

Tetapi pertama-tama, Anda harus menginstal kerangka kerja Django dan Django REST pada mesin lokal Anda. Kerangka kerja Django REST penting untuk membangun API di Django.

1. Buka terminal Anda dan jalankan pip perintah di bawah ini untuk menginstal django dan djangorestframework pada mesin lokal Anda. 

pip install django djangorestframework

2. Selanjutnya, jalankan perintah berikut untuk membuat direktori bernama ~/django_recipe_api dan arahkan ke direktori itu. Direktori ini akan berisi semua file yang diperlukan untuk proyek ini. 

mkdir ~/django_recipe_api
cd ~/django_recipe_api

3. Jalankan perintah berikut untuk membuat proyek Django baru (recipe_api ) dan aplikasi (recipe ) di direktori saat ini tempat API akan hidup. 

# Create a new Django project named "recipe_api" in the current directory.
django-admin startproject recipe_api .
# Create an app named "recipe" in the current directory where the API will live.
python manage.py startapp recipe

4. Sekarang buka ~/django_recipe_api/recipe_api/settings.py file di editor teks pilihan Anda, dan tambahkan kode berikut.

Kode di bawah ini menambahkan rest_framework ke aplikasi (resep) yang Anda buat sebelumnya (langkah ketiga). 

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
		'rest_framework' # for Django REST Framework to work
    'recipe', # newly created app
]

5. Buka ~/django_recipe_api/recipe/models.py file dan paste kode di bawah ini.

Kode di bawah ini memulai bidang dan jenis data yang akan Anda simpan dalam database. 

from django.db import models

class Recipe(models.Model):
    """Recipe object"""
    title = models.CharField(max_length=255)
    time_minutes = models.IntegerField()
    ingredients = models.CharField(max_length=255)
   # display an instance of the model when necessary
    def __str__(self):
        return self.title

6. Buat file lain bernama ~/django_recipe_api/recipe/serializers.py dan isi file dengan kode di bawah ini.

Kode di bawah ini membuat serializer untuk model yang Anda buat sebelumnya (langkah lima). Serializer membantu mengonversi data dari API ke dalam bentuk, seperti JSON, yang dapat digunakan di frontend. 

from dataclasses import fields
from rest_framework import serializers
from .models import Recipe
 
# create a serializer
class RecipeSerializer(serializers.Serializer):
    # initialize model and fields you want to serialize
    class Meta:
        model = Recipe
        fields = ('title', 'time_minutes', 'ingredients')

7. Sekarang buat file bernama ~/django_recipe_api/recipe/views.py dan rekatkan kode di bawah ini.

Kode di bawah ini membuat viewset untuk mengembalikan data dari API ke frontend dan menangani permintaan GET dari pengguna. 

from rest_framework import viewsets
from .serializers import RecipeSerializer #impor the serializer we just created
from .models import Recipe
 

class recipe_view_set(viewsets.ModelViewSet):
    # define queryset
    queryset = Recipe.objects.all()
    serializer_class = RecipeSerializer

8. Terakhir, buka file di jalur ~/django_recipe_api/recipe_api/urls.py dan ganti kode pada file tersebut dengan kode dibawah ini.

Dalam kode di bawah ini, Anda sedang menyetel URL sehingga Django REST Framework dapat terhubung ke aplikasi Anda dengan benar. Anda juga menyatakan rute yang akan digunakan saat mengakses API di browser. 

from django.contrib import admin
from django.urls import path, include
from recipe.views import recipe_view_set
from rest_framework import routers

# define the router
router = routers.DefaultRouter()
router.register(r'recipe', recipe_view_set) #the route tha will be used to access your API on the browser

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include(router.urls)),
    path('api-auth/', include('rest_framework.urls')) # Adds 'Login' link in the top right of the page

]

Membuat Dockerfile untuk Membangun API Django

Saat ini, Anda hanya memiliki API Django yang tidak ditampung dengan cara apa pun. Menampung aplikasi Anda memudahkan kolaborasi dan penerapan jika diperlukan.

Buat file bernama Dockerfile di root proyek Anda dan isi file dengan kode di bawah ini. Sebuah Dockerfile berisi daftar instruksi yang digunakan Docker untuk membangun image Docker Anda.

Kode di bawah ini membuat direktori di penampung Anda dan menyalin kode di mesin lokal Anda ke dalam penampung.

# The image you are going to inherit your Dockerfile from
FROM python:3.7-alpine
# Necessary, so Docker doesn't buffer the output and that you can see the output 
# of your application (e.g., Django logs) in real-time.
ENV PYTHONUNBUFFERED 1
# Make a directory in your Docker image, which you can use to store your source code
RUN mkdir /django_recipe_api
# Set the /django_recipe_api directory as the working directory
WORKDIR /django_recipe_api
# Copies from your local machine's current directory to the django_recipe_api folder 
# in the Docker image
COPY . .
# Copy the requirements.txt file adjacent to the Dockerfile 
# to your Docker image
COPY ./requirements.txt /requirements.txt
# Install the requirements.txt file in Docker image
RUN pip install -r /requirements.txt
# Create a user that can run your container
RUN adduser -D user
USER user

Sekarang, buat requirements.txt file di root proyek Anda dan masukkan teks di bawah ini.

Di bawah ini adalah daftar dependensi yang diperlukan untuk menjalankan proyek Anda.

django==3.1.2
djangorestframework==3.13.1

Membangun Berkas Tulis Docker untuk Menjalankan Django dan PostgreSQL

Anda baru saja membangun image Docker aplikasi Anda, tetapi bagaimana Anda menjalankannya? Docker-compose adalah alat yang digunakan untuk menjalankan image Docker dari mesin lokal. Docker-compose membantu Anda mengelola berbagai layanan dalam aplikasi Anda, seperti Django dan database.

1. Buat file bernama docker-compose.yml di root proyek Anda dan rekatkan kode di bawah ini.

Kode di bawah ini memetakan port dari mesin lokal Anda ke port gambar Anda dan menjalankan aplikasi Anda. 

# Verion of docker-compose to use 
version: "3"

services:
  django_recipe_api:
    build:
      context: . #Sets the directory for docker-compose to build.

    # Maps port on the local machine to port on Docker image
    ports:
      - "8000:8000"
      
    volumes: 
    # Copy changes made to the project to your image in real-time.
      - .:/django_recipe_api
    # Handles the command used to run the project in the Docker container.
    command: sh -c "python manage.py runserver 0.0.0.0:8000"

2. Selanjutnya, buka settings.py your Anda file dan tambahkan 0.0.0.0 sebagai nilai ALLOWED_HOSTS karena Docker berjalan di host (0.0.0.0). ALLOWS_HOSTS variabel menyimpan daftar domain/host yang dapat mengakses aplikasi Anda. 

ALLOWED_HOSTS = ['0.0.0.0']

3. Jalankan perintah berikut untuk menghasilkan database untuk model API Anda. 

# Generates the SQL code for yuou models.
sudo docker-compose run django_recipe_api sh -c "python manage.py makemigrations" 
# Runs the SQL commands that you generated.
sudo docker-compose run django_recipe_api sh -c "python manage.py migrate"

4. Sekarang, jalankan setiap perintah di bawah ini untuk membangun dan menjalankan wadah Django Anda. 

sudo docker-compose build # Build your Service
sudo docker-compose up # Runs your application

5. Terakhir, buka browser web pilihan Anda dan navigasikan ke http://0.0.0.0:8000/recipe/ untuk menjalankan API Anda.

Seperti yang Anda lihat di bawah, API Anda berjalan dengan sempurna, yang memungkinkan Anda menambahkan resep.

Mengonfigurasi PostgreSQL ke W ork dengan Docker dan Django

Anda sedang bekerja dengan SQLite sebagai database saat ini, yang tidak ideal saat Anda ingin menskalakan aplikasi Anda. Opsi yang lebih baik yang terhubung baik dengan Django adalah PostgreSQL, yang akan Anda tambahkan ke aplikasi Anda.

Untuk mengonfigurasi PostgreSQL agar bekerja dengan Docker dan Django:

1. Buka Dockerfile your Anda dan tambahkan kode di bawah ini di atas RUN pip install -r /requirements.txt garis. Dependensi ini diperlukan agar PostgreSQL bekerja dengan baik dengan Django. 

RUN apk add --update postgresql-client jpeg-dev
RUN apk add --update --virtual .tmp-build-deps \
      gcc libc-dev linux-headers postgresql-dev musl-dev zlib zlib-dev

2. Selanjutnya, buka requirements.txt file dan tambahkan psycopg2==2.8.6 persyaratan.

3. Jalankan kembali perintah di bawah ini untuk membuat gambar lagi. 

docker-compose build

4. Buka settings.py your Anda file, dan ganti DATABASES blok dengan kode berikut.

Kode di bawah ini memperbarui basis data Anda di Django untuk menggunakan PostgreSQL.

os modul digunakan dalam kode di bawah ini, jadi Anda harus menambahkan import os di bagian atas ~/django_recipe_api/recipe_api/settings.py Anda konten file. 

DATABASES = {
  'default': {
    'ENGINE': 'django.db.backends.postgresql',
    'HOST': os.environ.get('DB_HOST'),
    'NAME': os.environ.get('DB_NAME'),
    'USER': os.environ.get('DB_USER'),
    'PASSWORD': os.environ.get('DB_PASS'),
  }
}

5. Buka docker-compose.yml file dan ganti konten file dengan kode di bawah ini.

Kode di bawah ini membuat layanan untuk basis data yang Anda buat (langkah empat) dan mengumpankan kredensial basis data ke Django. 

# Verion of docker-compose to use 
version: "3"

services:
  django_recipe_api:
    build:
      context: . # Sets the directory for docker-compose to build.

    # Maps port on the local machine to port on Docker image
    ports:
      - "8000:8000"
      
    volumes: 
    # Copy changes made to the project to your image in real-time.
      - .:/django_recipe_api
    # Handles the command used to run the project in the Docker container.  
    command: sh -c "python manage.py runserver 0.0.0.0:8000" 
    
    environment:
			# The environment variable credetials that is needed 
      # in the settings for Postgres.
      - DB_HOST=db
      - DB_NAME=recipe
      - DB_USER=postgres
      - DB_PASS=supersecretpassword
    depends_on:
      - db

  db:
    image: postgres:10-alpine
    environment:
			# credentials required by postgres:10-alpine
      - POSTGRES_DB=recipe
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=supersecretpassword

6. Jalankan perintah berikut untuk menerapkan migrasi untuk database baru yang Anda buat (langkah lima). 

sudo docker-compose build
sudo docker-compose run django_recipe_api sh -c "python manage.py makemigrations"
sudo docker-compose run django_recipe_api sh -c "python manage.py migrate"

7. Sekarang, jalankan perintah berikut untuk menjalankan aplikasi Django Anda di wadah Docker.

sudo docker-compose up

8. Terakhir, navigasikan ke http://0.0.0.0:8000/recipe/ di browser Anda lagi.

Seperti yang Anda lihat di bawah, data yang disimpan sebelumnya tidak ada lagi karena Anda telah mengubah database Anda. Sekarang Anda dapat melanjutkan dan menambahkan lebih banyak data jika Anda mau.

Kesimpulan

Dalam tutorial ini, Anda belajar menyiapkan wadah Docker untuk Django API yang menggunakan PostgreSQL untuk menyimpan data. Anda juga telah melalui peluncuran kontainer Django menggunakan Dockerfile dan docker-compose.yml file.

Pada titik ini, Anda telah menguasai dasar-dasar menjalankan aplikasi dalam wadah Docker. Jadi, aplikasi lain apa yang ingin Anda jalankan di wadah Docker? Mungkin wadah Docker untuk wadah Django dan MongoDB?


Docker

  1. Cara Membuat, Mendaftar &Menghapus Wadah Docker di Linux

  2. Cara Menjalankan MySQL Dalam Wadah Docker

  3. Cara SSH Ke Wadah Docker

  1. Cara Menetapkan IP Statis ke Wadah Docker

  2. Cara Menginstal Vim di Wadah Docker

  3. Cara Keluar dari Kontainer Docker

  1. Cara membuat gambar khusus dari wadah Docker

  2. Cara Membuat Wadah Docker MySQL untuk Pengujian

  3. Cara membuat Gambar Docker dari Wadah dan File Docker