ใช้งาน Docker ร่วมกับ Django สำหรับผู้เริ่มต้น (Development Mode)

ในบทความนี้จะเกี่ยวข้องกับการใช้งาน Docker ร่วมกับ Django แบบเบื้องต้น ซึ่งทั้งตัว Django และตัวของ Docker เองแน่นอนว่าเป็นสิ่งที่น่าสนใจทั้งคู่ เมื่อนำทั้งสองอย่างมาใช้งานร่วมกันก็จะช่วยให้ process การทำงานเป็นไปได้อย่างลื่นไหลมากขึ้นเนื่องจากจะทำให้โค้ดที่พัฒนาอยู่เข้าใกล้ความเป็น production มากขึ้นนั่นเอง และบทความนี้เราจะมาเรียนรู้กันเรื่องของการใช้งาน Docker ร่วมกับ Django ใน Development Mode กันก่อน (หมายถึงตอนที่กำลังเขียนโค้ดอยู่) เพื่อความง่าย และจะยังไม่ได้เอาไป deploy กันจริงๆ เอาไว้เดี๋ยวรอบทความถัดๆไปครับ****

จุดประสงค์

1. รู้จัก Docker อะไรคือ Docker?
2. เขียน Dockerfile ซึ่งใช้ในการสร้าง Container ใน Docker
3. สร้าง Container และรันด้วย Docker

Software & Tools

• Docker
• Python 3+
• Django 3+
• VS Code

Docker คืออะไร ?

มารู้จักกันก่อนว่าอะไรเอ่ยคือ Docker ถ้าพูดถึง Docker แล้วหลายๆคนน่าจะนึกถึงภาพของวาฬน่ารักๆตัวนึงซึ่งกำลังขน container กันอยู่ใช่มั้ยครับ สิ่งที่เรามักจะใช้ Docker ทำกันคือการทำสิ่งที่เรียกว่า Container ซึ่งมันคืออะไรกันเนี่ย เดี๋ยวเรามาเล่าถึงประวัติศาสตร์ของโลกของการ deploy สิ่งต่างๆกันก่อน ยุคแรกสุดเลยเวลาเราจะ deploy อะไรก็ตามนี่เราก็จะต้องมีเซิฟเวอร์เป็นของตัวเองก่อนครับ คือต้องซื้อเครื่องมาเลยเครื่องนึง จากนั้นก็ไปทำการ config ต่างๆ setup บลาๆ ซึ่งทำให้มันสามารถเชื่อมต่อกับโลกของอินเตอร์เน็ตได้

Docker (Photo: docker.com)

แน่นอนแหละครับว่าการมีเซิฟเวอร์เป็นของตัวเองก่อน เวลาจะรันอะไรก็ลำบาก แถมยังแพงอีกต่างหาก เราก็เลยมีการแบ่งเซิฟเวอร์ใช้งานกันครับ หมายความว่าเราไม่จำเป็นที่ต้องใช้เซิฟเวอร์ 1 เครื่องรัน services 1 ตัว แต่เราสามารถใช้เซิฟเวอร์เครื่องเดียวกันนี้ รันหลายๆ service พร้อมๆกันไปได้ ประหยัดเงินไปตั้งเยอะ

Server (Photo: canva.com)

แต่ปัญหาก็ยังไม่จบอยู่แค่นั้นครับ เพราะมันอาจจะปัญหาเรื่องของ Dependencies หรือ Library ต่างๆได้ ลองนึกภาพถ้าผมกำลังรัน service ตัวนึง ซึ่งใช้ Python 2 (แอบเก่า;) ) แต่ปรากฎว่ามีเพื่อนที่จะต้องการมาแชร์เครื่องด้วยกันต้องการที่จะใช้งาน Python 3 ที่นี้ก็จะเกิดปัญหาขึ้นมาครับ เพราะเวอร์ชันของ Depencdencies ที่เราต้องการมันไม่ตรงกัน!! ซึ่งแน่นอนว่าเป็นเรื่องที่ปวดหัวมากเพราะฉะนั้นจึงมีการพัฒนาสิ่งหนึ่งขึ้นมาครับ คือสิ่งที่เรียกว่า Virtual Machines (ยังไม่ถึง Docker นะครับ)

Virtual Machine (VM)

มาทำความรู้จัก VM กันสักหน่อยครับ

VM (Photo: howtogeek.com)

Virtual Machine ทำให้เราสามารถจำลองคอมพิวเตอร์ขึ้น บนคอมพิวเตอร์ได้ ที่นี้เวลาเราอยากจะรัน services อะไรเราก็แค่จำลองคอมพิวเตอร์ขึ้นมา แล้วก็ลงแค่ dependencies ที่ต้องการในคอมพิวเตอร์จำลองนั้น ก็จะหมดปัญหาเรื่อง dependencies ตีกันไปได้ครับ แน่นอนว่ามาถึงยุค Virtual Machine แล้วแต่ก็ยังสามารถพัฒนาต่อไปได้ ก็เลยถึงยุคของพระเอกเราในบทความนี้ครับก็คือ Docker นั่นเอง!! (จริงๆแล้วปัจจุบันก็มีสิ่งเจ๋งๆกว่า Docker อยู่เหมือนกันครับ แต่บทความนี้เอา Docker ก่อนแล้วกัน)

ปัญหาของ Virtual Machine คือการจะจำลองคอมพิวเตอร์ขึ้นมา 1 เครื่องเราจะต้องติดตั้งอะไรต่าง ๆ มากมาย ไม่ว่าจะเป็น OS หรือองค์ประกอบต่างๆที่ใช้ในการควบคุมเพื่อจำลองคอมพิวเตอร์ 1 เครื่องขึ้นมา (ใครเคยเล่นพวก VirtualBox จะพอรู้ครับว่ามันกินทรัพยากรสูงมากๆ) สิ่งที่ Docker ทำคือการสร้างสิ่งที่เรียกว่า Container ขึ้นมา โดย Container นึกภาพให้เหมือนกับว่าเป็น environment นึงที่ถูกสร้างขึ้นบนคอมพิวเตอร์ แล้วก็ทำหน้าที่ contain (เป็นกล่อง) สิ่งต่างๆที่เราต้องการใส่ลงไปครับนั่นก็คือการทำงานของ Docker นั่นเอง แต่ถึงแนวคิดของมันจะเรียบง่ายแต่เบื้องหลังการทำงานของมันมีความซับซ้อนพอตัวเลยครับ เช่นว่ามีการใช้งาน Linux อยู่เบื้องหลัง คอยทำหน้าที่จัดสรรทรัพยากรต่างๆ ทำงานกับ Filesystem บลาๆๆ ซึ่งตรงนี้ผมจะขอข้ามไปครับคร่าวๆของ Docker ก็จะประมาณนี้นั่นเอง

ติดตั้ง Docker

วิธีการติดตั้ง Docker ผมจะขออนุญาตข้ามไปนะครับ แต่การติดตั้งไม่ได้ซับซ้อนมากสามารถอ่านได้ที่ Docs ของ Docker โดยตรงได้เลยครับ https://docs.docker.com/get-docker/

สร้าง container

แล้วเราจะสร้าง Container ยังไง? การสร้าง Container มีหลายวิธีครับ แต่วิธีที่เป็นที่นิยมที่สุด (เรียกได้ว่า ควรจะทำมากที่สุด) คือการสร้าง Dockerfile ขึ้นมาครับ

โดยสิ่งที่เรียกว่า Dockerfile นี้ก็จะเป็นสิ่งที่ทำหน้าที่บอกองค์ประกอบต่างๆที่เราต้องการให้ container ที่เราต้องการสร้างเป็นครับ แต่เดี๋ยวก่อน ก่อนอื่นที่เราจะเริ่มเขียน Dockerfile กันเรามาไล่เรียงกันดีกว่าว่าการจะสร้างโปรเจค django ขึ้นมาโปรเจคท์หนึ่งนั้นเราต้องทำอะไรกันบ้าง (นับตั้งแต่ 0 เพิ่งได้คอมพิวเตอร์มาเลยครับ 555) โดยสามารถทำได้ตามขั้นตอนดังต่อไปนี้

1. ติดตั้ง python ก่อน
2. ใช้คำสั่ง pip install django
3. รันคำสั่ง django-admin startproject <ชื่อโปรเจค>
4. เมื่อจะรันก็ใช้คำสั่ง python manage.py runserver

(env) pip install python
(env) pip install django
(env) django-admin startproject <ชื่อโปรเจคท์>
(env) cd <ชื่อโปรเจคท์>
(env) python manage.py runserver

หน้า default ของ django

แชว้บ~ ได้จรวดพร้อมโปรเจคท์ Django มาโปรเจคท์หนึ่ง เดี๋ยวเรามาต่อกันที่ Docker กันดีกว่าข้างบนเป็นขั้นตอนเมื่ออยากที่จะสร้างโปรเจคท์ใหม่ขึ้นมาใช่มั้ยครับ แต่ถ้าหากเราจะใช้งาน Docker เราจะต้องทำเหมือนกับว่า เราต้องการจะเอาโปรเจคท์ของเรา ไปรันในเครื่องอื่นเราจะทำยังไงกันก็อย่างแรกเลยคือเราต้องมีรายชื่อของ library python ที่เราจะใช้กันก่อนครับ ก็ใช้คำสั่ง

$ pip freeze > requirements.txt

เพื่อนำ library ต่างๆของเรามาก่อน

asgiref==3.3.1
Django==3.1.4
pytz==2020.5
sqlparse==0.4.1

ทดสอบโปรเจคท์ใน Environment ใหม่ (สมมติเป็นเครื่องเพื่อน)

เดี๋ยวเรามาไล่ขั้นตอนกันใหม่ดีกว่าว่าถ้าเรายก Django ของเราไปเครื่องเพื่อนเราจะทำยังไง เริ่มกันตั้งแต่ 0 ได้คอมมาใหม่ๆเหมือนเดิมครับ โดยมีขั้นตอนดังนี้

1. ติดตั้ง python
2. ก็อปไฟล์ requirements.txt ไป ติดตั้งด้วยคำสั่ง pip install -r requirements.txt
3. ก็อปไฟล์ django ไป
4. รันคำสั่ง python manage.py runserver เพื่อรัน

เมื่อได้ขั้นตอนนี้มาแล้วเดี๋ยวมาสร้างไฟล์ Dockerfile กันเลยครับ สร้างไฟล์ใหม่ชื่อ Dockerfile มาก่อน จากนั้นพิมพ์ลงไปตามนี้ครับ

Dockerfile

FROM python:3
 
WORKDIR /app
 
COPY requirements.txt .
RUN pip install -r requirements.txt
 
COPY . .
 
EXPOSE 8000
CMD ["python3", "manage.py", "runserver", "0.0.0.0:8000"]

โดยสิ่งที่เราเขียนไปใน Dockerfile ก็จะเป็นไปตามขั้นตอนที่เราไล่ไปในข้างบนเด๊ะๆเลย (มีแปลกๆตรง EXPOSE เดี๋ยวไว้อธิบายข้างล่างอีกทีครับ)

สร้างและรัน docker container

ก่อนอื่นเราจะต้องทำการ build ไฟล์ Dockerfile ของเราก่อนครับ ซึ่งการ Build เมื่อเสร็จสิ้นเราจะได้สิ่งที่เรียกว่า Image ออกมา เมื่อได้ Image เราจึงจะสามารถนำไปสร้าง Container ได้ครับ Build ด้วยคำสั่ง docker build -t <ชื่อ image ที่ต้องการตั้งfile

ตัวอย่างเช่น

$ pip freeze > requirements.txt

ตอนรันระวังอย่าลืม(Dot) . ด้วยนะครับ

เมื่อได้ image มาแล้วให้ใช้คำสั่งรันด้วยการรันตามนี้ครับ

$ docker run -p 8000:8000 -v $(pwd):/app <ชื่อ image ที่พึ่งตั้งไป>

Note: Windows: ไม่มีคำสั่งpwd ใช้เป็น%cd% แทนครับ

เดี๋ยวไว้มาอธิบายกันดีกว่าว่าคำสั่งนี้มันทำอะไรได้บ้างครับ คำสั่งพื้นฐานสุดๆเลยคือ docker run <ชื่อ image> แค่เพียงเท่านี้เราก็สามารถที่จะรัน Container ได้แล้ว แต่เราเพิ่มแท็ก -p และ -v ขึ้นมาเนื่องจากว่าจำเป็นต้องมีการ config ให้เจ้า container สามารถสื่อสารกับเราได้ครับ

-p ใช้สำหรับการ map port โดยปกติแล้วเมื่อสร้าง container ขึ้นมาตัว docker จะไม่ได้มีการเชื่อมพอร์ตให้เราโดยอัตโนมัติ เราจำเป็นที่จะต้องเชื่อมเองครับ -p 8000:8000 หมายถึงเชื่อมต่อพอร์ต 8000 ของเครื่องเราเข้ากับ 8000 ของตัว container (EXPOSE ใน Dockerfile ก็มีไว้เพื่อเหตุผลเดียวกันครับ)

-v คล้ายๆกันกับการ map port แต่ว่าเรา map พื้นที่ใน harddisk ของเราแทนครับ -v $(pwd):/app ของผมคือการ map directory ปัจจุบันของผมเข้ากับ /app ในตัว container นั่นเอง pwd ใน Unix เป็นคำสั่งเพื่อแสดงที่อยู่ไดเรคทอรี่ปัจจุบันของเรา

เมื่อรันคำสั่งแล้วลองเปิด localhost:8000 ดูก็จะเห็น

รันได้เหมือนกันกับเครื่องต้นทาง

แสดงว่าการใช้งาน Docker ร่วมกับ Django ของเราเสร็จสมบูรณ์ครับ ตอนนี้ก็ถ้าใครอยากลองแก้ไขไฟล์ดูแล้วดูว่าหน้าเว็บของเราเปลี่ยนไปด้วยหรือไม่ก็สามารถลองทำได้ตามสะดวกเลยครับ สำหรับบทความนี้ก็ขอขอบคุณมากครับ เจอกันใหม่บทความหน้าครับ