Cara Mengatur Lingkungan Pengembangan Django di Ubuntu 18.04

Django adalah kerangka kerja web yang kuat yang dapat membantu Anda mendapatkan aplikasi atau situs web Python Anda dari awal. Django menyertakan server pengembangan yang disederhanakan untuk menguji kode Anda secara lokal, tetapi untuk apa pun yang terkait dengan produksi sedikit pun, diperlukan server web yang lebih aman dan kuat (Nginx - Apache).

Dalam panduan ini, kami akan mendemonstrasikan bagaimana menginstal dan mengkonfigurasi beberapa komponen pada Ubuntu 18.04 untuk mendukung dan melayani aplikasi Django. Kami akan menyiapkan database PostgreSQL daripada menggunakan database SQLite default. Kami akan mengkonfigurasi server aplikasi Gunicorn untuk berinteraksi dengan aplikasi kami. Kami kemudian akan menyiapkan Nginx untuk membalikkan proxy ke Gunicorn, memberi kami akses ke fitur keamanan dan kinerjanya untuk melayani aplikasi kami.

Buat pengguna non-root dengan hak istimewa sudo yang dikonfigurasi

Masuk sebagai root
Membuat pengguna baru
```
# adduser bobby
```
Memberikan Keistimewaan Administratif
Untuk menambahkan hak istimewa ini ke pengguna baru kami, kami perlu menambahkan pengguna baru ke grup sudo. Secara default, di Ubuntu 18.04, pengguna yang termasuk dalam grup sudo diizinkan untuk menggunakan perintah sudo.
```
# usermod -aG sudo bobby
```

Instal Paket dari Repositori Ubuntu

Untuk memulai prosesnya, kita akan mengunduh dan menginstal semua item yang kita butuhkan dari repositori Ubuntu. Kami akan menggunakan pip pengelola paket Python untuk menginstal komponen tambahan nanti.
Kita perlu memperbarui indeks paket apt lokal dan kemudian mengunduh dan menginstal paket. Paket yang kami instal bergantung pada versi Python mana yang akan digunakan proyek Anda.
Menginstal Django dengan Python 3, ketik :

$ sudo apt-get update
$ sudo apt-get install python3-pip python3-dev libpq-dev postgresql postgresql-contrib nginx

Ini akan menginstal pip, file pengembangan Python yang diperlukan untuk membangun Gunicorn nanti, sistem database Postgres dan perpustakaan yang diperlukan untuk berinteraksi dengannya, dan server web Nginx.

Buat Database dan Pengguna PostgreSQL

Kita akan langsung masuk dan membuat database dan pengguna database untuk aplikasi Django kita. Secara default, Postgres menggunakan skema otentikasi yang disebut otentikasi rekan untuk koneksi lokal. Pada dasarnya, ini berarti bahwa jika nama pengguna sistem operasi pengguna cocok dengan nama pengguna Postgres yang valid, pengguna tersebut dapat masuk tanpa otentikasi lebih lanjut.

Selama instalasi Postgres, pengguna sistem operasi bernama postgres dibuat agar sesuai dengan pengguna administratif PostgreSQL postgres. Kita perlu menggunakan pengguna ini untuk melakukan tugas administratif. Kita dapat menggunakan sudo dan memasukkan nama pengguna dengan opsi -u.

Masuk ke sesi Postgres interaktif dengan mengetik :

$ sudo -u postgres psql

Anda akan diberikan prompt PostgreSQL di mana kami dapat mengatur persyaratan kami.

Pertama, buat database untuk proyek Anda

Postgres=# CREATE DATABASE newproject;

Catatan: Setiap pernyataan Postgres harus diakhiri dengan titik koma

Selanjutnya, buat pengguna database untuk proyek kita. Pastikan untuk memilih kata sandi yang aman

Postgres=# CREATE USER newprojectuser WITH PASSWORD 'password';

Setelah itu, kita akan memodifikasi beberapa parameter koneksi untuk pengguna yang baru saja kita buat. Ini akan mempercepat operasi database sehingga nilai yang benar tidak perlu ditanyakan dan disetel setiap kali koneksi dibuat.

Kami sedang menyetel pengkodean default ke UTF-8, yang diharapkan Django. Kami juga menyetel skema isolasi transaksi default untuk membaca commit, yang memblokir pembacaan dari transaksi yang tidak dilakukan. Terakhir, kami mengatur zona waktu. Secara default, proyek Django kami akan disetel untuk menggunakan UTC. Ini semua adalah rekomendasi dari proyek Django itu sendiri.

Postgres=# ALTER ROLE newprojectuser SET client_encoding TO 'utf8';
Postgres=# ALTER ROLE newprojectuser SET default_transaction_isolation TO 'read committed';
Postgres=# ALTER ROLE newprojectuser SET timezone TO 'UTC';

Sekarang, kami dapat memberikan akses pengguna baru kami untuk mengelola database baru kami

Postgres=# GRANT ALL PRIVILEGES ON DATABASE newproject TO newprojectuser;

Setelah selesai, keluar dari prompt PostgreSQL dengan mengetik:

Postgres=# \q

Buat Lingkungan Virtual Python 3 untuk Proyek Anda

Sekarang kami memiliki database kami, kami dapat mulai menyiapkan sisa persyaratan proyek kami. Kami akan menginstal persyaratan Python 3 kami dalam lingkungan virtual untuk pengelolaan yang lebih mudah.

Untuk melakukan ini, pertama-tama kita perlu akses ke perintah virtualenv. Kita dapat menginstal ini dengan pip3.

Tingkatkan pip3 dan instal paket dengan mengetik:

  $ sudo -H pip3 install --upgrade pip
  $ sudo -H pip3 install virtualenv

Dengan virtualenv terinstal, kita dapat mulai membentuk proyek kita. Buat dan pindahkan ke direktori tempat kita dapat menyimpan file proyek kita:

  $ mkdir ~/djangoproject
  $ cd ~/djangoproject

Di dalam direktori proyek, buat lingkungan virtual Python dengan mengetik:

$ virtualenv djangoprojectenv

Ini akan membuat direktori bernama djangoprojectenv di dalam djangoproject . Anda direktori. Di dalam, itu akan menginstal versi lokal Python dan versi lokal pip. Kita dapat menggunakan ini untuk menginstal dan mengonfigurasi lingkungan Python yang terisolasi untuk proyek kita.

Sebelum kita menginstal persyaratan Python proyek kita, kita perlu mengaktifkan lingkungan virtual. Anda dapat melakukannya dengan mengetik:

$ source djangoproject/bin/activate

Prompt Anda harus berubah untuk menunjukkan bahwa Anda sekarang beroperasi dalam lingkungan virtual Python. Ini akan terlihat seperti ini:(djangoprojectenv)user@host:~/djangoproject$ .
Dengan lingkungan virtual Anda aktif, instal Django, Gunicorn, dan adaptor PostgreSQL psycopg2 dengan instance lokal pip:

Catatan: Terlepas dari versi Python 3 atau python 2 yang Anda gunakan, saat lingkungan virtual diaktifkan, Anda harus menggunakan perintah pip (bukan pip3).

(djangoprojectenv)$ pip install django gunicorn psycopg2-binary

Anda sekarang seharusnya memiliki semua perangkat lunak yang diperlukan untuk memulai proyek Django.

Membuat dan Mengonfigurasi Proyek Django Baru

Dengan komponen Python kami terinstal, kami dapat membuat file proyek Django yang sebenarnya.

Karena kita sudah memiliki direktori proyek, kita akan memberitahu Django untuk menginstal file-file di sini. Ini akan membuat direktori tingkat kedua dengan kode aktual, yang normal, dan menempatkan skrip manajemen di direktori ini. Kuncinya adalah bahwa kita mendefinisikan direktori secara eksplisit alih-alih mengizinkan Django membuat keputusan relatif terhadap direktori kita saat ini:

(djangoprojectenv)$ django-admin.py startproject djangoproject ~/djangoproject

Pada titik ini, direktori proyek Anda (~/djangoproject dalam kasus kami) harus memiliki konten berikut:

~/djangoproject/manage.py :Skrip manajemen proyek Django.
~/djangoproject/myproject/ :Paket proyek Django. Ini harus berisi __init__.py , settings.py , urls.py , dan wsgi.py file.
~/djangoproject/djangoprojectenv/ :Direktori lingkungan virtual yang kita buat sebelumnya.

Hal pertama yang harus kita lakukan dengan file proyek yang baru dibuat adalah menyesuaikan pengaturan. Buka file pengaturan di editor teks Anda:

(djangoprojectenv)$ nano ~/djangoproject/djangoproject/settings.py

Mulailah dengan menemukan direktif ALLOWED_HOSTS. Ini mendefinisikan daftar alamat server atau nama domain dapat digunakan untuk menghubungkan ke instans Django. Setiap permintaan masuk dengan header Host yang tidak ada dalam daftar ini akan menimbulkan pengecualian. Django mengharuskan Anda menyetel ini untuk mencegah kelas kerentanan keamanan tertentu.

Dalam tanda kurung siku, daftarkan alamat IP atau nama domain yang terkait dengan server Django Anda. Setiap item harus dicantumkan dalam kutipan dengan entri dipisahkan dengan koma. Jika Anda menginginkan permintaan untuk seluruh domain dan subdomain apa pun, tambahkan titik di awal entri. Dalam cuplikan di bawah, ada beberapa contoh komentar yang digunakan untuk mendemonstrasikan.

~/djangoproject/djangoproject/settings.py
. . .
# The simplest case: just add the domain name(s) and IP addresses of your Django server
# ALLOWED_HOSTS = [ 'example.com', '203.0.113.5']
# To respond to 'example.com' and any subdomains, start the domain with a dot
# ALLOWED_HOSTS = ['.example.com', '103.25.111.5']
ALLOWED_HOSTS = ['your_server_domain_or_IP', 'second_domain_or_IP', . . .]

Selanjutnya, temukan bagian yang mengonfigurasi akses database. Ini akan dimulai dengan DATABASES. Konfigurasi dalam file adalah untuk database SQLite. Kami telah membuat database PostgreSQL untuk proyek kami, jadi kami perlu menyesuaikan pengaturan.

Ubah pengaturan dengan informasi database PostgreSQL Anda. Kami memberitahu Django untuk menggunakan psycopg2adaptor yang kami instal dengan pip. Kita perlu memberikan nama database, username database, password pengguna database, dan kemudian menentukan bahwa database terletak di komputer lokal. Anda dapat membiarkan pengaturan PORT sebagai string kosong:

~/djangoproject/djangoproject/settings.py
. . .
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'newproject',
        'USER': 'newprojectuser',
        'PASSWORD': 'password',
        'HOST': 'localhost',
        'PORT': '',
    }
}
. . .

Selanjutnya, pindah ke bagian bawah file dan tambahkan pengaturan yang menunjukkan di mana file statis harus ditempatkan. Ini diperlukan agar Nginx dapat menangani permintaan untuk item ini. Baris berikut memberitahu Django untuk menempatkan mereka di direktori yang disebut static di direktori proyek dasar:

~/djangoproject/djangoproject/settings.py
. . .
STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE_DIR, 'static/')

Simpan dan tutup dengan mengetik Ctrl + x file ketika Anda selesai.
Sekarang, kita dapat memigrasikan skema database awal ke database PostgreSQL menggunakan skrip manajemen:

(djangoprojectenv)$ ~/djangoproject/manage.py makemigrations
(djangoprojectenv)$ ~/djangoproject/manage.py migrate

Buat pengguna administratif untuk proyek dengan mengetik:

(djangoprojectenv)$ ~/djangoproject/manage.py createsuperuser

Anda harus memilih nama pengguna, memberikan alamat email, dan memilih serta mengonfirmasi kata sandi.
Kami dapat mengumpulkan semua konten statis ke dalam lokasi direktori yang kami konfigurasikan dengan mengetik:

(djangoprojectenv)$ ~/djangoproject/manage.py collectstatic

Anda harus mengkonfirmasi operasi. File statis kemudian akan ditempatkan di direktori bernama static di dalam direktori proyek Anda.

Jika Anda mengikuti panduan penyiapan server awal, Anda harus memiliki firewall UFW yang melindungi server Anda. Untuk menguji server pengembangan, kita harus mengizinkan akses ke port yang akan kita gunakan.

Buat pengecualian untuk port 8000 dengan mengetik:

(djangoprojectenv)$ sudo ufw allow 8000

Terakhir, Anda dapat menguji proyek Anda dengan memulai server pengembangan Django dengan perintah ini:

(djangoprojectenv)$ ~/djangoproject/manage.py runserver 0.0.0.0:8000

Di browser web Anda, kunjungi nama domain atau alamat IP server Anda diikuti dengan :8000:

http://server_domain_or_IP:8000

Anda akan melihat halaman indeks Django default untuk Django 2.0.7:

Jika Anda mengetik http://server_domain_or_IP:8000/admin di bilah alamat, Anda akan diminta memasukkan nama pengguna dan kata sandi administratif yang Anda buat dengan perintah createsuperuser:

Setelah mengautentikasi, Anda dapat mengakses antarmuka admin Django default:

Setelah selesai menjelajah, tekan CTRL-C di jendela terminal untuk mematikan server pengembangan.

Menguji Kemampuan Gunicorn untuk Melayani Proyek

Hal terakhir yang ingin kami lakukan sebelum meninggalkan lingkungan virtual kami adalah menguji Gunicorn untuk memastikan bahwa itu dapat melayani aplikasi. Kita dapat melakukannya dengan memasukkan direktori proyek kita dan menggunakan gunicorn untuk memuat modul WSGI proyek:

(djangoprojectenv)$ cd ~/djangoproject
(djangoprojectenv)$ gunicorn --bind 0.0.0.0:8000 djangoproject.wsgi

Ini akan memulai Gunicorn pada antarmuka yang sama yang dijalankan oleh server pengembangan Django. Anda dapat kembali dan menguji aplikasi lagi.

Catatan: Antarmuka admin tidak akan menerapkan gaya apa pun karena Gunicorn tidak tahu tentang konten CSS statis yang bertanggung jawab atas hal ini.

Kami memberikan modul kepada Gunicorn dengan menetapkan jalur direktori relatif ke file wsgi.py Django, yang merupakan titik masuk ke aplikasi kami, menggunakan sintaks modul Python. Di dalam file ini, fungsi yang disebut aplikasi didefinisikan, yang digunakan untuk berkomunikasi dengan aplikasi.

Saat Anda selesai menguji, tekan CTRL-C di jendela terminal untuk menghentikan Gunicorn.

Kita sekarang telah selesai mengonfigurasi aplikasi Django kita. Kita dapat mundur dari lingkungan virtual kita dengan mengetik:

(myprojectenv)$ deactivate

Indikator lingkungan virtual di perintah Anda akan dihapus.

Buat File Layanan Gunicorn systemd

Kami telah menguji bahwa Gunicorn dapat berinteraksi dengan aplikasi Django kami, tetapi kami harus menerapkan cara yang lebih kuat untuk memulai dan menghentikan server aplikasi. Untuk mencapai ini, kami akan membuat file layanan systemd.

Buat dan buka file layanan systemd untuk Gunicorn dengan hak istimewa sudo di editor teks Anda:

$ sudo nano /etc/systemd/system/gunicorn.service

Mulailah dengan [Unit] bagian, yang digunakan untuk menentukan metadata dan dependensi. Kami akan menempatkan deskripsi layanan kami di sini dan memberi tahu sistem init untuk hanya memulai ini setelah target jaringan tercapai.

Selanjutnya, kita akan membuka [Service] bagian. Kami akan menentukan pengguna dan grup yang ingin kami proses untuk dijalankan. Kami akan memberikan kepemilikan akun pengguna reguler kami atas proses tersebut karena ia memiliki semua file yang relevan. Kami akan memberikan kepemilikan grup ke www-data grup sehingga Nginx dapat berkomunikasi dengan mudah dengan Gunicorn.

Kami kemudian akan memetakan direktori kerja dan menentukan perintah yang akan digunakan untuk memulai layanan. Dalam hal ini, kita harus menentukan path lengkap ke executable Gunicorn, yang diinstal dalam lingkungan virtual kita. Kami akan mengikatnya ke soket Unix di dalam direktori proyek karena Nginx diinstal pada komputer yang sama. Ini lebih aman dan lebih cepat daripada menggunakan port jaringan. Kami juga dapat menentukan tweak Gunicorn opsional di sini. Misalnya, kami menentukan 3 proses pekerja dalam kasus ini.

Terakhir, kita akan menambahkan [Install] bagian. Ini akan memberi tahu systemd ke mana harus menautkan layanan ini jika kami mengaktifkannya untuk memulai saat boot. Kami ingin layanan ini dimulai ketika sistem multi-pengguna biasa aktif dan berjalan:

/etc/systemd/system/gunicorn.service
[Unit]
Description=gunicorn daemon
After=network.target

[Service]
User=bobby
Group=www-data
WorkingDirectory=/home/bobby/djangoproject
ExecStart=/home/bobby/djangoproject/djangoproject/bin/gunicorn --access-logfile - --workers 3 --bind unix:/home/bobby/djangoproject/djangoproject.sock djangoproject.wsgi:application

[Install]
WantedBy=multi-user.target

Dengan itu, file layanan systemd kami selesai. Simpan dan tutup sekarang.

kita harus menambahkan pengguna bobby ke grup www-data:

$ sudo usermod –a –G www-data bobby

Kami sekarang dapat memulai layanan Gunicorn yang kami buat dan mengaktifkannya sehingga dimulai saat boot:

$ sudo systemctl start gunicorn
$ sudo systemctl enable gunicorn

Kami dapat mengonfirmasi bahwa operasi berhasil dengan memeriksa file soket.

Periksa status proses untuk mengetahui apakah proses dapat dimulai:

$ sudo systemctl status gunicorn

Selanjutnya, periksa keberadaan djangoproject.sock file dalam direktori proyek Anda:

$ ls /home/bobby/djangoproject
Output
manage.py  djangoproject  djangoprojectenv  djangoproject.sock  static

Jika perintah systemctl status menunjukkan bahwa terjadi kesalahan atau jika Anda tidak menemukan djangoproject.sock file di direktori, ini merupakan indikasi bahwa Gunicorn tidak dapat memulai dengan benar. Periksa log proses Gunicorn dengan mengetik:

$ sudo journalctl -u gunicorn

Lihat pesan di log untuk mencari tahu di mana Gunicorn mengalami masalah. Ada banyak alasan mengapa Anda mengalami masalah, tetapi sering kali, jika Gunicorn tidak dapat membuat file soket, itu karena salah satu alasan berikut:

File proyek dimiliki oleh pengguna root, bukan pengguna sudo
WorkingDirectory jalur dalam /etc/systemd/system/gunicorn.service file tidak mengarah ke direktori proyek
Opsi konfigurasi yang diberikan untuk proses gunicorn di ExecStart arahan tidak tepat. Periksa item berikut:
- Jalur ke biner gunicorn menunjuk ke lokasi biner sebenarnya dalam lingkungan virtual
- --bind direktif mendefinisikan file yang akan dibuat dalam direktori yang dapat diakses oleh Gunicorn
- djangoproject.wsgi:application adalah jalur akurat ke callable WSGI. Ini berarti bahwa ketika Anda berada di WorkingDirectory, Anda seharusnya dapat mencapai aplikasi bernama yang dapat dipanggil dengan melihat di djangoproject.wsgi modul (yang diterjemahkan menjadi file bernama ./djangoproject/wsgi.py )

Jika Anda membuat perubahan pada file /etc/systemd/system/gunicorn.service, muat ulang daemon untuk membaca ulang definisi layanan dan mulai ulang proses Gunicorn dengan mengetik:

$ sudo systemctl daemon-reload
$ sudo systemctl restart gunicorn

Pastikan Anda memecahkan masalah di atas sebelum melanjutkan.

Konfigurasi Nginx ke Proxy Pass ke Gunicorn

Sekarang Gunicorn sudah diatur, kita perlu mengonfigurasi Nginx untuk meneruskan lalu lintas ke proses. Mulailah dengan membuat dan membuka blok server baru di direktori yang tersedia di situs Nginx:

$ sudo nano /etc/nginx/sites-available/djangoproject

Di dalam, buka blok server baru. Kita akan mulai dengan menetapkan bahwa blok ini harus mendengarkan pada port normal 80 dan harus merespons nama domain atau alamat IP server kita.

Selanjutnya, kami akan memberi tahu Nginx untuk mengabaikan masalah apa pun dengan menemukan favicon. Kami juga akan memberi tahunya di mana menemukan aset statis yang kami kumpulkan di ~/djangoproject/static kami direktori. Semua file ini memiliki awalan URI standar "/static" , sehingga kami dapat membuat blok lokasi untuk mencocokkan permintaan tersebut.

Terakhir, kita akan membuat blok lokasi / {} untuk mencocokkan semua permintaan lainnya. Di dalam lokasi ini, kami akan menyertakan proxy_params standar file yang disertakan dengan instalasi Nginx dan kemudian kami akan meneruskan lalu lintas ke soket yang dibuat oleh proses Gunicorn kami:

/etc/nginx/sites-available/djangoproject
server {
    listen 80;
    server_name server_domain_or_IP;

    location = /favicon.ico { access_log off; log_not_found off; }
    location /static/ {
        root /home/bobby/djangoproject;
    }
    location / {
        include proxy_params;
        proxy_pass http://unix:/home/bobby/djangoproject/djangoproject.sock;
    }
}

Simpan dan tutup file setelah Anda selesai. Sekarang, kita dapat mengaktifkan file dengan menautkannya ke sites-enabled direktori:

$ sudo ln -s /etc/nginx/sites-available/djangoproject /etc/nginx/sites-enabled

Uji konfigurasi Nginx Anda untuk kesalahan sintaks dengan mengetik:

$ sudo nginx -t

Jika tidak ada kesalahan yang dilaporkan, lanjutkan dan mulai ulang Nginx dengan mengetik:

$ sudo systemctl restart nginx

Terakhir, kita perlu membuka firewall untuk lalu lintas normal pada port 80. Karena kita tidak lagi memerlukan akses ke server pengembangan, kita juga dapat menghapus aturan untuk membuka port 8000:

$ sudo ufw delete allow 8000
$ sudo ufw allow 'Nginx Full'

Anda seharusnya sekarang dapat pergi ke domain atau alamat IP server Anda untuk melihat aplikasi Anda.