Tag: django

  • djsurvey – Google Forms Alternative #01

    ต่อจาก ddready – แพ็ครวม django + bootstrap4 + crispy form + docker พร้อมใช้งาน ในบทความนี้ ผมได้พยายามทำให้ใช้งาน Django ได้ง่ายขึ้น จนได้ แบบสำรวจอย่างง่าย พร้อมใช้งาน ใน 3 ขั้นตอน

    Prerequesite

    ติดตั้ง Python 3.6+ หรือ ใช้ Python Container แล้ว

    Repository

    https://github.com/nagarindkx/djsurvey

    ง่าย ๆ 3 ขั้นตอน

    1. Clone Repository

    ใช้คำสั่ง git

    git clone https://github.com/nagarindkx/djsurvey.git

    หรือ Download ไปก็ได้

    https://github.com/nagarindkx/djsurvey/archive/master.zip

    2. กำหนดข้อคำถามในแบบสำรวจ

    แก้ไขไฟล์

    /code/main/survey/models.py

    ตัวอย่างเช่น แบบสำรวจ ประกอบด้วย

    1. ชื่อ
    2. อีเมล
    3. เพศ
    4. วันเดือนปีเกิด
    5. ผลไม้ที่ชอบ
    6. ข้อเสนอแนะ

    ก็สร้าง Model ตามนี้ ( แรก ๆ อาจจะรู้สึกน่ากลัว แต่พอเข้าใจแล้ว มันง่ายมาก)

    from django.db import models
    class Survey(models.Model):
        fullname = models.CharField(
            verbose_name="ชื่อ",
            max_length=255,  blank=False)
        email = models.EmailField(
            verbose_name="อีเมล",
            blank=False)
        gender = models.CharField(
            verbose_name="เพศ",
            max_length=1,    blank=False,
            choices=[('F', 'หญิง'), ('M', 'ชาย')],
            default='F',
        )
        birthdate = models.DateField(
            verbose_name="วันเดือนปีเกิด",
            auto_now=False,  blank=False)
        fruit = models.CharField(
            verbose_name="ผลไม้ที่ท่านชอบ",
            max_length=1,    blank=False,
            choices=[('a', 'แอปเปิ้ล'), ('b', 'มะละกอ'),
                     ('c', 'กล้วย'), ('d', 'ส้ม')],
            default='c',
        )
        comment = models.TextField(
            verbose_name="ข้อเสนอแนะ",
            blank=True)

    แนะนำให้ใช้ Visual Studio Code จะทำงานได้ง่ายมาก

    3. Migrate แล้ว Run

    ใช้คำสั่งต่อไปนี้

    python manage.py migrate
    python manage.py runserver 0:8080

    ชมผลงาน

    http://localhost:8080/survey/

    หรือ ตกแต่งอีกนิดหน่อย ก็จะได้แบบนี้

    http://localhost:8080/advancedsurvey/

    สำหรับผู้ที่ใช้ Docker สามารถ ทำตามขั้นตอนใน แนวทางการพัฒนา Web Application ด้วย django จาก local docker สู่ Google Cloud Run เพื่อนำขึ้น Google Cloud Run ได้เลย (แต่ต้องเชื่อมกับ Database จริง ๆ ก่อนนะ – โปรดติดตามตอนต่อไป)

    คุณกำลังเจอปัญหาเหล่านี้อยู่ใช่ไม๊ ?

    • Google Forms ก็ง่ายดีแหล่ะ แต่ จะทำอย่างไรให้เก็บข้อมูลไว้ในฐานข้อมูลได้ ?
    • อยากให้ ผู้ใช้งาน Upload เอกสารเข้ามา / แก้ไขข้อมูล ซึ่ง Google Forms ก็ทำได้ แต่ต้อง Login ด้วย Google Account ก่อน จึงจะทำได้
    • Google Forms ก็ทำ Conditions ได้แหล่ะ (Go to section base on answer) แต่ ถ้าจะให้มีการคำนวนที่ซับซ้อนกว่านั้น ก่อนจะเลือกคำถามถัดไป จะทำอย่างไร ?

    ปัญหาเหล่านี้จะหมดไป เมื่อคุณใช้ Django !

    • ติดตั้งได้ บน Web Server ของคุณ!
    • Login ด้วย Facebook/Twitter/Google/Line หรือ Email หรือ จะเป็น Single Sign-On ก็ยังได้
    • ทุกอย่างสามารถ Customize ได้ ทำแบบสอบถามที่ซับซ้อนได้

    ไว้เจอกันในตอนต่อ ๆ ไปครับ

  • ddready – แพ็ครวม django + bootstrap4 + crispy form + docker พร้อมใช้งาน

    สำหรับใครที่อยากจะลองพัฒนา Web Application ด้วย django web framework ผมได้รวบรวมเป็นชุดเริ่มต้น ซึ่งจะสามารถสร้าง Responsive Web และ มีแบบฟอร์มที่สวยงามด้วย crispy form มาเรียบร้อย ใช้งานได้ทั้ง แบบ Python บนเครื่อง และ แบบ Docker ลองทำตามดูได้ครับ

    ต้นแบบ มี Bootstrap 4 พร้อมใช้งาน
    มี Login Form มาให้เลย
    เข้ามาในส่วนของ Profile และ Logout ได้

    Repository

    สามารถเปิด URL ต่อไปนี้ เพื่อไป Download หรือ จะใช้ git clone ก็ได้

    https://github.com/nagarindkx/ddready.git

    https://gitlab.psu.ac.th/kanakorn.h/ddready.git

    จากนั้น ให้เปิด cmd ไปยังตำแหน่งที่ clone ลงมา

    สำหรับผู้ที่ติดตั้ง python อยู่แล้ว

    แล้วใช้คำสั่งต่อไปนี้

    pip install -r requirements.txt
    cd code
    cd main
    waitress-serve --listen *:8080 main.wsgi:application

    สำหรับผู้ที่จะใช้ Docker

    บน Windows ใช้คำสั่งต่อไปนี้

    set PROJECTNAME="projectname"
    set GCP-PROJECT-ID="gcp-project-id"
    set SERVICE="service"
    docker build --rm -f "Dockerfile" -t %PROJECTNAME%:dev .
    docker run -d -v %CD%\code:/code -p 8080:8080 --name %PROJECTNAME% %PROJECTNAME%:dev
    docker exec -it %PROJECTNAME% /bin/sh -c "[ -e /bin/bash ] && /bin/bash || /bin/sh"

    ทดสอบใช้งาน

    http://localhost:8080

    ในตอนต่อไป จะแนะนำวิธีการสร้าง แบบสอบถาม ทดแทนการใช้ Google Forms ครับ

  • [Share and Tell] การพัฒนา Web Application ด้วย django ด้วย Docker และการนำไปใช้งานบน Google Cloud Run

    1.ชื่องานที่ทำ

    การพัฒนา Web Application ด้วย django ด้วย Docker และการนำไปใช้งานบน Google Cloud Run

    2.เป้าหมายของงานที่ทำ

    • เพื่อประยุกต์ใช้งาน Docker ในการพัฒนางาน ทำให้สามารถลดความไม่เข้ากันของรุ่นของซอฟต์แวร์ หรือ ไลบรารี่ในเครื่องพัฒนาได้
    • เพื่อผลักดันการทำงานแบบ Containerize ในองค์กร เป็นต้นแบบการลดความซ้ำซ้อนของการสร้างเซิร์ฟเวอร์แบบ Virtual Machine ทำให้เกิดการใช้งานทรัพยากรอยู่จำกัดให้มีประสิทธิภาพมากขึ้น
    • เพื่อเป็นต้นแบบการทำงานแบบ Serverless ด้วย Google Cloud Run
    • เพื่อเป็นต้นแบบการใช้งาน LINE Front-End Framework ในการทำ Chatbot

    3.สภาพแวดล้อมที่เกี่ยวกับงานที่ทำ

    • Operating System: Windows 10
    • Editor: Visual Studio Code
    • Environment: Docker Oriented
    • Programming Language: python
    • Web Framework: django + crispy form + bootstrap + jQuery
    • Mobile Development: LINE with LIFF (และถ้าเตรียมทัน จะแนะนำการพัฒนา Mobile Application ด้วย Google Flutter)
    • Database: postgresql, Google BigQuery
    • Machine Learning: Google Vision API

    4.บรรยายสรุปสั้น ๆ ว่า ต้องใช้อะไรบ้างและทำอย่างไร (ไม่ต้องลงขั้นตอนละเอียด)

    • ติดตั้ง Microsoft Visual Studio Code (VS Code) และ Docker Extension
    • ใช้ docker เพื่อ pull image ของ Environment ที่ต้องการมา สร้างเป็น Container แล้ว พัฒนาลงไปในนั้น โดยใช้วิธี Bind mount volume เข้าไป แล้วใช้ VS Code เขียน และทำงานผ่าน Attach Shell
    • ติดตั้ง Python Package ที่เกี่ยวข้อง ได้แก่ django + crispy form + bootstrap + jQuery
    • พัฒนา Web Application ด้วย django ตั้งแต่การสร้าง Data Model, สร้างแบบฟอร์ม รวมถึงการสร้าง RESTFul API และ การส่งข้อมูลไปให้ Google Vision API ทำงาน แล้วส่งผลกลับมา
    • พัฒนา LINE Front-End Framework เพื่อใช้เป็น User Interface แบบ Chatbot
    • (ถ้าเตรียมทัน) จะสาธิตการพัฒนา Mobile Application ด้วย Google Flutter

    5.อื่น ๆ อยากบอกอะไรเพิ่มเติม เขียนเพิ่มได้

    Man – a being in search of meaning.

    Plato, 429 BC
  • แนวทางการพัฒนา Web Application ด้วย django จาก local docker สู่ Google Cloud Run

    ในการพัฒนาแอพพลิเคชั่น เราก็จะเจอปัญหานึงเสมอ ๆ คือ เวอร์ชั่น (Version) ของเครื่องมือที่ใช้ในการพัฒนานั้น แต่ละโปรเจคมีความแตกต่างกัน เช่น ในกรณีของ การพัฒนา Web Application ด้วย django web framework เราอาจจะอยากใช้ python รุ่นล่าสุด คือ 3.8 แต่ในขณะเดียวกัน เมื่อหลังบ้านต้องการไปติดต่อ Tensorflow 2.0 ซึ่งยังต้องใช้งานกับ Python 3.6 เป็นต้น วิธีแก้ไขปัญหาทั่วไปคือ ติดตั้ง package ‘virtualenv’ เพื่อให้การพัฒนาแต่ละโปรเจค มี Environment แตกต่างกันได้

    แต่จากการใช้งานจริง พบว่า สุดท้าย ตอนเอาไป Production บนเครื่อง Server ก็ต้องตามไปติดตั้งเครื่องมือ และรุ่นที่ถูกต้อง แม้ใน Python จะมีคำสั่ง pip install -r requirements.txt ก็ตาม แต่ก็ยังไปติดปัญหาว่า OS ของเครื่องที่จะ Production นั้น รองรับรุ่นของเครื่องมืออีกหรือไม่ด้วย

    แนวทางการใช้ Container ด้วย Docker จึงเป็นที่นิยม เพราะ เมื่อเราพัฒนาเสร็จแล้ว สามารถ Pack เข้าไปใน Container แล้วเอาไป Deploy ได้ โดย (แทบจะ) ไม่ต้องกังวลกับ Environment ปลายทาง อีกทั้ง ยังสามารถทดสอบ Environment ใหม่ ๆ ก่อนจะ Deploy ได้ด้วย เช่นการเปลี่ยนรุ่นของ Python เป็นต้น

    ในบทความนี้ จะนำเสนอ แนวทางการสร้าง docker container เพื่อใช้เป็นฐานในการพัฒนา django และ สามารถต่อยอด ติดตั้ง package อื่น ๆ ตามต้องการ ตั้งแต่ Development ไปจนถึง Deployment สู่ Serverless Environment อย่าง Google Cloud Run

    สร้าง Development Container

    เริ่มจาก สร้างโฟลเดอร์ใหม่ขึ้นมา ในนั้นมี 2 ไฟล์ คือ Dockerfile และ requirements.txt กับ โฟลเดอร์ ชื่อ code

    Dockerfile

    • ใช้ image ของ python เป็นรุ่น 3.7-slim ซึ่งตัดส่วนที่ไม่จำเป็นออกแล้ว (ไม่ใช้ alpine เนื่องจาก พบรายงานว่า แม้จะมีขนาดเล็กกว่า แต่ถูกจำกัดทรัพยากรบางอย่าง ทำให้ทำงานได้ช้ากว่า)
    • สร้าง /code แล้วเข้าไปใช้พื้นที่นี้ (เหมือนคำสั่ง mkdir /code ; cd /code อะไรประมาณนั้น)
    • สั่งให้ copy ไฟล์ requirements.txt ไปใช้ที่ root ( / )
    • จากนั้น Upgrade คำสั่ง pip เป็นรุ่นล่าสุด แล้ว ติดตั้ง package ตามที่กำหนดใน requirements.txt
    • เปิด Port 8080 ไว้ เพื่อใช้ในการทดสอบ และเป็นไปในแนวทางเดียวกับการใช้บน Google Cloud Run ต่อไป
    FROM python:3.7-slim
    WORKDIR /code/
    COPY requirements.txt /
    RUN pip install -U pip \
        && pip install -r /requirements.txt
    EXPOSE 8080

    requirements.txt

    ในการพัฒนา django เมื่อทำการติดตั้ง package ใดเพิ่มเติมด้วยคำสั่ง pip install ก็จะบันทึกรายการ พร้อมรุ่นของ package มาในไฟล์นี้ ในที่นี้ ใช้ django, guincorn และ whitenoise เป็นหลัก (จะมีรายการ dependency ติดเข้ามาด้วย)

    Django==2.2.6
    gunicorn==19.9.0
    pytz==2019.3
    sqlparse==0.3.0
    whitenoise==4.1.4

    จากนั้นใช้คำสั่งต่อไปนี้ สร้าง (build) docker image จากไฟล์ Dockerfile ข้างต้น โดยมี option ที่เกี่ยวข้องดังนี้

    docker build --rm -f "Dockerfile" -t mydjango:dev .
    • –rm เมื่อ build แล้ว ก็ลบ container ชั่วคราวทิ้ง
    • -f กำหนดว่าจะเรียกจากไฟล์ใด วิธีนี้ มีประโยชน์ เวลาที่จะต้องมี Dockerfile ทั้ง Development และ Production ในโฟลเดอร์เดียวกัน ซึ่งจำเป็นต้องใช้ชื่อไฟล์ที่แตกต่างกัน
    • -t เป็นตั้งชื่อ docker image และ ชื่อ tag
    • . คือ ให้ build จากตำแหน่งปัจจุบัน

    ขั้นตอนนี้จะได้ docker image ชื่อ mydjango และมี tag เป็น dev แล้ว้

    (ในที่นี้ พัฒนาบนเครื่องคอมพิวเตอร์ที่เป็น Windows 10 ซึ่ง %CD% จะให้ค่า Current Directory แบบ Absolute path ออกมา เช่นเดียวกับบน Linux ที่ใช้ $(pwd) )

    ต่อไป สั่ง run ด้วยคำสั่ง และ options ดังต่อไปนี้

    docker run --rm -it -p 8080:8080  -v %CD%\code:/code  mydjango:dev bash
    • –rm เมื่อจบการทำงาน ก็ลบ container ชั่วคราวทิ้ง
    • -it คือ interactive และเปิด TTY
    • -p เพื่อเชื่อม port 8080 จากภายนอก เข้าไปยัง port 8080 ภายใน container
    • -v เพื่อเชื่อม Volume หรือโฟลเดอร์ของเครื่อง host กับ /code ภายใน container ขั้นตอนนี้สำคัญ
    • bash ข้างท้าย เพื่อส่งคำสั่ง เรียก bash shell ขึ้นมา ซึ่งจะสัมพันธ์กับ -it ข้างต้น ทำให้สามารถใช้งาน shell ภายใน container ได้เลย

    ผลที่ได้คือ bash shell และ อยู่ที่ /code ภายใน container

    root@757bcbb07c7f:/code#

    ตอนนี้ เราก็สามารถสร้าง django ได้ตามปรกติแล้ว (คลิกดูตัวอย่างเบื้องต้น) แต่ในตัวอย่างนี้ จะเริ่มจากการสร้าง project ชื่อ main เพื่อใช้ในขั้นตอนต่อไป ด้วยคำสั่งต่อไปนี้

    django-admin startproject main
    cd main

    ในระหว่างการพัฒนา สามารถใช้คำสั่ง runserver โดยเปิด Port 8080 ใน container เพื่อทดสอบได้ดังนี้ (สอดคล้องตามที่อธิบายข้างต้น)

    python manage.py runserver 0.0.0.0:8080

    สร้าง Production Docker Image

    คำสั่งข้างต้น สามารถใช้ได้เฉพาะขั้นตอนการพัฒนา แต่เมื่อพัฒนาเสร็จแล้ว ควรใช้ Application Server แทน ในที่นี้จำใช้ gunicorn แต่ก่อนอื่น จะต้องปรับ Configuration ของ django ให้พร้อมในการ Deployment ก่อน

    main/settings.py

    # แก้ไข
    DEBUG = False
    ALLOWED_HOSTS = ['localhost','SERVICE-ID.run.app']
    
    # เพิ่ม
    MIDDLEWARE = [
        ...
        # Whitenoise
        'whitenoise.middleware.WhiteNoiseMiddleware',
        ...
    ]
    # เพิ่ม
    STATIC_ROOT = os.path.join(BASE_DIR, 'static')

    มีเพิ่มเติมคือ whitenoise ซึ่งเป็น package สำหรับจัดการเกี่ยวกับการให้บริการ static file ในตัว มิเช่นนั้นจะต้องไปตั้งค่าใน Web Server ให้จัดการแทน

    เมื่อเราตั้งค่า DEBUG = False จะต้องกำหนด ALLOWED_HOSTS เสมอ ในที่นี้กำหนดให้เป็น localhost และ Production URL (SERVICE-ID.run.app) ที่จะเกิดขึ้นเมื่อสร้าง Service บน Google Cloud Run ครั้งแรกไปแล้ว (ค่อยกลับมาแก้ไขแล้ว Revision อีกครั้ง)

    ใช้คำสั่งต่อไปนี้เพื่อรวบรวม static files ต่าง ๆ มาไว้ในที่เดียวกัน ในที่นี้ คือที่ โฟลเดอร์ static

    python manage.py collectstatic

    ทดสอบ Production ด้วย gunicorn ด้วยคำสั่งต่อไปนี้

    gunicorn --bind 0.0.0.0:8080 main.wsgi

    ทดสอบเรียก Local Admin Console ( http://localhost:8080/admin ) ดู ถ้าเรียก static file เช่นกลุ่ม css ได้ ก็พร้อมสำหรับจะนำขึ้น Google Cloud Run ต่อไป

    สุดท้าย สร้าง Production Dockerfile และ สรุป requirements.txt ดังนี้

    Dockerfile.production

    FROM python:3.7-slim
    WORKDIR /code
    COPY ./code/* ./
    RUN pip install -U pip \
        && pip install -r requirements.txt
    EXPOSE 8080
    CMD [ "gunicorn","--bind","0.0.0.0:8080", "main.wsgi"]

    requirements.txt

    pip freeze > requirements.txt

    จากนั้น ใช้คำสั่งต่อไปนี้ เพื่อสร้าง Production Docker Image (ออกมาจาก Development Container shell ก่อน) โดยจะใช้ tag เป็น latest

    docker build -t mydjango:latest -f "Dockerfile.production" .

    ส่ง Production Docker Image ขึ้น Google Container Registry

    Google Cloud Run จะเรียกใช้ docker image ที่อยู่บน Google Container Registry เท่านั้น

    • เปิด Google Console
    • สร้าง Project ใหม่ และ ตั้งค่า Billing
    • เปิดใช้งาน Google Cloud Run และ Google Container Registry
    • ติดตั้อง Google Cloud SDK เพื่อให้สามารถ push ขึ้นได้ และ ยืนยันตัวตนด้วย Google Account

    แล้วใช้คำสั่งต่อไปนี้ เพื่อ tag

    docker tag mydjango:latest gcr.io/YOUR-GCP-PROJECT-ID/SERVICE-NAME
    • YOUR-GCP-PROJECT-ID เป็น Project ID ที่สร้างขึ้น
    • SERVICE-NAME ชื่อ service ที่จะสร้าง

    แล้วก็ push ขึ้น Google Container Registry

    docker push gcr.io/YOUR-GCP-PROJECT-ID/SERVICE-NAME

    สร้าง Google Cloud Run Service

    สร้าง Service โดยเลือก Image ที่ต้องการ

    เมื่อเสร็จแล้วจะได้ URL อย่าลืมเอาไปแก้ไขใน main/settings.py ในส่วนของ ALLOWED_HOSTS แทน SERVICE-ID.run.app

    จากนั้น build, tag และ push ขึ้น Google Cloud Registry อีกครั้ง แล้ว Deploy New Revision เป็นอันเรียบร้อย

    อันนี้เป็นการ Proof of Concept ในบทความต่อไป จะนำเสนอตัวอย่างการใช้งานจริงครับ

  • django – as a Dialogflow Webhook #03

    บทความนี้ จะกล่าวถึง การใช้ django ทำหน้าที่เป็น Webhook จาก Dialogflow ผ่าน Fulfillment ทาง HTTP Post Request ด้วย JSON object และ ทำการประมวลผล แล้วตอบกลับไปเป็น JSON Object เช่นกัน เพื่อให้ Dialogflow ตอบสนองต่อผู้ใช้ได้ตามต้องการ เช่น อาจจะให้ไปค้นข้อมูลจากฐานข้อมูลในองค์กรมาตอบ เป็นต้น

    Source: https://dialogflow.com/docs/intro/fulfillment

    ในมุมของ django django (ดี)จังโก้ ดีอย่างไร #01 ได้กล่าวถึงการสร้าง Web Application จาก Model โดยกำหนด Fields ต่าง ๆ จากนั้น django ก็จะสร้าง Web Form ต่าง ๆ ให้อัตโนมัติ และยังสามารถสร้าง Users ของระบบ พร้อมทั้ง กำหนดสิทธิ์การเข้าถึงของแต่ละคนได้อีกด้วย แล้วนำไปผูกกับส่วน Admin เพื่อให้ผู้ใช้ทำการ Authentication ก่อนเข้าจัดการกับข้อมูลต่างได้ และในบทความ django – Deploy to Production #02 ได้แนะนำวิธีการ Deploy ระบบที่สร้างขึ้นสู่ Production ตามลำดับ

    ในบทความนี้ จะใช้ “view” ซึ่งเป็นอีกส่วนของ django ตามขั้นตอนต่อไปนี้

    ใน myproject สร้าง App ใหม่ ชื่อ fulfillment

    python manage.py startapp fulfillment

    เพิ่ม ‘fulfillment’ app ลงใน myproject/settings.py ที่ INSTALLED_APPS
    ( ในตัวอย่างก่อนหน้า เราเพิ่ม worklog app ไว้แล้ว) 

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

    จากนั้น แก้ไขไฟล์ myproject/fulfillment/views.py ตามนี้

    from django.http import HttpRequest, HttpResponse
    from django.views.decorators.csrf import csrf_exempt
    import json
    # Create your views here.
    @csrf_exempt
    def sayHi(request):
        j = json.loads(request.body)
        x = {  "fulfillmentText": "This is a text response"
            }
        return HttpResponse(json.dumps(x))

    ในส่วนนี้ จะ import packages ต่อไปนี้

    • HttpRequest เพื่อรับ Input ผ่าน HTTP
    • HttpResponse เพื่อตอบ Output ผ่าน HTTP
    • csrf_exempt เพื่อบอกว่า ยอมให้ทำงานผ่าน HTTP POST โดยไม่ต้องมี CSRF Token (ถ้าไม่ใส่ อยู่ ๆ จะส่ง POST เข้ามาไม่ได้ )
    • json เพื่อจัดการ JSON object

    จากนั้น สร้าง Function ชื่อ “sayHi” มี function ที่เรียกใช้งานดังนี้

    • json.loads(request.body) ทำหน้าที่แปลง JSON Object จาก HTTP Request เข้ามาอยู่ในรูป Python Object ในที่นี้ จะนำข้อมูลจาก Dialogflow Fulfillment ที่ได้จาก Intent Matching และ Parameter Extraction ส่งมา
    • json.dumps(x) ทำหน้าที่แปลงข้อมูล จาก Python Object (ในรูปแบบ dict) ไปเป็น JSON Object ในที่นี้ แปลง { “fulfillmentText” : “This is a text response” } ไปเป็น JSON Object แล้วตอบกลับไปทาง HTTP Response

    ต่อไป สร้างไฟล์ myproject/fulfillment/urls.py เพื่อกำหนด URL ที่จะเรียกใช้ function ดังนี้

    from django.urls import path
    from . import views
    urlpatterns = [    
    	path('hi', views.sayHi )
    ]

    ในส่วนนี้ import package “path” เข้ามา และ import views ที่สร้างขึ้นใน ‘fulfillment’ app และกำหนดว่า เมื่อการเรียก “hi” ให้ไปเรียก function “sayHi” ซึ่งเป็น views

    สุดท้าย แก้ไขไฟล์ myproject/urls.py เพื่อเพิ่ม URL path ให้ fulfillment

    from django.contrib import admin
    from django.urls import path, include
    urlpatterns = [
    	path('admin/', admin.site.urls),
    	path('fulfillment/', include('fullfillment.urls'))
    ]
    

    เมื่อมีการเรียก http://server-domain/fulfillment/ ก็จะส่งไปให้ views ใน fulfillment ทำงาน โดย Include fulfillment.urls เข้ามา

    เมื่อเรียก  http://server-domain/fulfillment/hi ก็จะไปเรียก function sayHi ที่เขียนข้างต้นนั่นเอง

    Dialogflow Fulfillment

    ใน Dialogflow Console คลิกที่ Fulfillment แล้ว Enable Webhook จากนั้นใส่ URL ของ django production server ที่เราสร้างขึ้น ในตัวอย่างจะเป็น

    https://xxxxxxxxx.psu.ac.th/fulfillment/hi

    จากนั้น กดปุ่ม Save ด้านล่าง (ในทางปฏิบัติจริง ๆ ต้องมีเรื่อง Authentication/Authorization อีกพอสมควร แต่ในตัวอย่างนี้ ทำแบบง่าย ๆ ก่อน)

    ต่อไป สร้าง Intent ชุดที่ต้องการให้ส่งให้ Fulfillment ทำงาน แล้วก็คลิกที่ Fulfillment > Enable webhook call for this intent แล้ว Save

    จากนั้น ลองทดสอบดู จะเห็นได้ว่า Default Response จะแสดงข้อความ “This is a text response” แทนที่จะเป็น Text Response ที่กำหนดใน Intent นั้น

    ลองคลิก Diagnostic Info

    จะเห็นว่า มี fulfillmentText เป็น “This is a text response” ตามที่เขียนไว้ เป็นอันว่า Dialogflow สามารถเชื่อมต่อไปยัง django Webhook ที่สร้างขึ้นได้แล้ว

    หวังว่าจะเป็นประโยชน์ครับ

  • django – Deploy to Production #02

    ต่อจาก django #01

    Development Environment

    เริ่มจาก ไปที่ command prompt แล้วใช้คำสั่งต่อไปนี้ เพื่อ เก็บรายละเอียดของ Package และ Version ที่ใช้ในการพัฒนา ไว้ในไฟล์ myenv.txt และ เก็บไฟล์ myproject ทั้งหมดไว้ในไฟล์ myproject.tar.gz (บน Windows อาจจะใช้ 7zip สร้าง)

    pip freeze > myenv.txt
    tar -zxvf myproject.tar.gz myproject

    แล้ว Upload ไฟล์ myenv.txt และ myproject.tar.gz ขึ้นบน Projection Server

    Production Server

    ในที่นี้ ลองไปใช้ Google Compute Engine สร้าง Instance ขึ้นมา เป็น Ubuntu 18.04 และ ได้ Upload ไฟล์ myenv.txt และ myproject.tar.gz จาก Development ขึ้นไว้แล้ว (ใน /home/user01)

    ติดตั้ง Python3, PIP, Apache2, และ mod_wsgi

    sudo apt update
    sudo apt install python3 python3-pip apache2 libapache2-mod-wsgi-py3

    ติดตั้ง virtualenv

    pip3 install virtualenv

    สร้าง Virtual Environment ชื่อ production

    virtualenv production
    source production/bin/activate

    ติดตั้ง Package ต่าง ๆ ตามที่สร้างไว้จาก Development Environment (จากไฟล์ myenv.txt)

    pip install -r myenv.txt

    แตกไฟล์ myproject.tar.gz ออกมา

    tar -zxvf myproject.tar.gz

    สร้าง Apache Site Configuration ที่ /etc/apache2/sites-available/001-myproject.conf

    เนื้อหาตามนี้

    <VirtualHost *:80>
        Alias /static /home/user01/myproject/static
        <Directory /home/user01/myproject/static>
            Require all granted
        </Directory>
        <Directory /home/user01/myproject/myproject>
            <Files wsgi.py>
                Require all granted
            </Files>
        </Directory>
    
        WSGIDaemonProcess myproject python-home=/home/user01/production python-path=/home/user01/myproject
        WSGIProcessGroup myproject
        WSGIScriptAlias / /home/user01/myproject/myproject/wsgi.py
    </VirtualHost>

    จากนั้น สร้าง Symbolic Link จาก /home/user01/production/lib/python3.6/site-packages/django/contrib/admin/static มาที่ /home/user01/myproject/static

    ln -s /home/user01/production/lib/python3.6/site-packages/django/contrib/admin/static /home/user01/myproject/static

    ปรับ Permission ให้ www-data สามารถแก้ไข Database ได้ (เพราะในที่นี้ใช้ SQLite)

    sudo chown :www-data /home/user01/myproject/db.sqlite3
    sudo chown :www-data /home/user01/myproject

    สั่ง Apache ให้เอา Default Site ออก และ นำ myproject ขึ้นแทน และ ทำการ Reload

    sudo a2dissite 000-default
    sudo a2ensite 001-myproject
    sudo systemctl reload apache2

    ก็จะใช้ได้แล้ว

    มีหน้า Admin ให้ใช้
    admin เข้าใช้งานได้
    User ก็สามารถเข้าใช้งานได้

    หวังว่าจะเป็นประโยชน์ครับ

  • django (ดี)จังโก้ ดีอย่างไร #01

    ขอไม่ลงรายละเอียดว่า อะไรคือ Web Framework, MVC, MVT พวกนั้นนะครับ อ่านเองที่ https://www.djangoproject.com/ และ เขียนวิธีติดตั้งบน Windows ไว้คร่าว ๆ ที่ ขั้นตอนการติดตั้ง django บน Windows และในที่นี้ใช้ Visual Studio Code เป็น Editor (สั่งด้วยคำสั่ง code …)

    โจทย์

    สมมุติในทีม มีคน 10 คน ต้องการ ระบบบันทึกการปฏิบัติงาน

    1. จัดเก็บข้อูล วันเวลาของงานที่ทำ, ประเภทของงงาน (ตาม TOR), รายละเอียดของงานที่ทำ, ระยะเวลาที่ใช้ไป (ชั่วโมง)
    2. แต่ละคน ต้อง Login เข้ามาก่อน จึงจะบันทึกปฏิบัติงานได้

    วิถีแบบ django

    สร้าง project ชื่อ myproject

    django-admin startproject myproject

    สร้าง App ชื่อ worklog

    cd myproject
    python manage.py startapp worklog

    สร้าง Model ว่าจะเก็บข้อมูลอะไรบ้าง

    แก้ไขไฟล์

    code worklog/models.py

    แล้วสร้าง Class ชื่อ Worklog เพื่อกำหนด Field เป็นช่องทางการเก็บค่าตามโจทย์ (Reference: https://docs.djangoproject.com/en/2.1/ref/models/fields/)
    –> ขั้นตอนนี้ เขียนใน Visual Studio Code เสร็จแล้ว Save and Exit

    from django.db import models
    from django.utils.timezone import now
    
    # Create your models here.
    class Worklog(models.Model):
        timestamp = models.DateTimeField(default = now())
        typeOfWork = models.ForeignKey('TypeOfWork', on_delete=models.CASCADE)
        work_text = models.TextField(default="")
        manhour = models.FloatField(default=0)
        def __str__(self):
            return self.work_text
    
    class TypeOfWork(models.Model):
        typeOfWork_text = models.CharField(max_length=200)
        def __str__(self):
            return self.typeOfWork_text

    บอกให้ django สร้างโครงสร้างฐานข้อมูลตามโมเดล (จาก Command Prompt)

    python manage.py migrate

    เพิ่ม App ‘worklog’ เข้าสู่ myproject

    แก้ไขไฟล์

    code myproject/settings.py

    เพิ่ม ‘worklog’ ในส่วนของ INSTALLED_APPS
    –> ขั้นตอนนี้ เขียนใน Visual Studio Code เสร็จแล้ว Save and Exit

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

    สร้าง Super User สักคนนึง

    python manage.py createsuperuser

    ตั้งชื่อว่า admin และ รหัสผ่านตามต้องการ

    เพิ่มโมเดล TypeOfWork และ WorkLog เข้าสู่หน้าของ Admin โดยการแก้ไขไฟล์
    –> ขั้นตอนนี้ เขียนใน Visual Studio Code เสร็จแล้ว Save and Exit

    code worklog/admin.py

    ดังนี้

    from django.contrib import admin
    
    # Register your models here.
    from .models import TypeOfWork, Worklog
    admin.site.register(TypeOfWork)
    admin.site.register(Worklog)

    สั่ง Run Server

    สั่งที่ Command Prompt

    python manage.py runserver

    แล้วเปิด Web Browser ไปที่
    http://127.0.0.1:8000/admin/

    ใส่ Login และ Password ของ admin ทั้งตั้งไว้ก่อนหน้านี้

    เริ่มต้นใช้งาน

    เพิ่มประเภทของงาน

    คลิก Type of works — django พยายามใส่ s ให้ด้วยอัตโนมัติ
    คลิกที่ปุ่ม ADD TYPE OF WORK
    เพิ่มประเภทของงาน วนไป
    เสร็จแล้วได้ผลประมาณนี้ อยากจะ Edit Delete ได้หมด

    เพิ่มบันทึกการปฏิบัติงาน

    คลิกที่ Add ในส่วนของ Worklogs

    มี Form สำหรับ Input ทันที

    สวยงาม ไม่ต้องทำอะไรเพิ่ม เลือก Type of works ได้ ช่องวันที่ เวลา ก็มี Widget ให้เรียบร้อย
    แก้ไขไป มี History ให้ด้วย

    จากนั้น ก็เพิ่มคนเข้าทีม ด้วยเมนู Users ได้

    ระบบ Security พร้อม

    User01 ตั้งค่าให้เป็น Worklog > Can Add Worklog
    ก็จะทำได้แค่เข้ามาบันทึกปฏิบัติงานเท่านั้น

    สรุป

    จะเห็นได้ว่า ด้วยการสร้างโมเดลเล็กน้อย django ก็สามารถสร้างระบบ User Entry ง่าย ๆ ที่มาพร้อม Security Features มากมายได้แล้ว ยังมีรายละเอียดอีกเยอะ โดยเฉพาะในส่วนของ View/Template ที่จะสร้าง User Input และการออกรายงานต่าง ๆ รวมถึง การสร้าง API และ RESTful API หรือ จะผูกกับ OAuth2 ก็ยังได้

    หวังว่าเป็นประโยชน์ครับ

  • ขั้นตอนการติดตั้ง Django ด้วย Python3 บน Windows

    ขั้นตอนการติดตั้ง Django ด้วย Python3 บน Windows

    1. ติดตั้ง Python จาก https://www.python.org/downloads/
    2. เปิด cmd โดย Run As Administrator
    3. ใช้คำสั่ง
      python -m pip install django
    4. ทดสอบโดยใช้คำสั่ง
      python -m django --version
    5. สร้าง Project ด้วยคำสั่ง
       django-admin startproject mysite
    6. เข้าไปใน project “mysite” directory ด้วยคำสั่ง
      cd mysite
    7. ทดสอบ runserver
      python manage.py runserver
    8. เปิด website:
      http://127.0.0.1:8000/

    เดี๋ยวมาต่อเรื่อง การสร้าง App, การใช้ Database, การ Authentication และการสร้าง REST API เพื่อใช้งานกับ OAuth2