หน้านี้ได้รับการแปลโดย Cloud Translation API

Django บน Cloud Run

1. บทนำ

Cloud Run เป็นแพลตฟอร์มการประมวลผลที่มีการจัดการซึ่งทำให้คุณเรียกใช้คอนเทนเนอร์แบบไม่เก็บสถานะที่เรียกใช้ผ่านคำขอ HTTP ได้ Cloud Run เป็นแบบ Serverless ด้วยการตัดการจัดการโครงสร้างพื้นฐานทั้งหมดออก คุณจึงมุ่งเน้นไปที่การสร้างแอปพลิเคชันที่ยอดเยี่ยม ซึ่งเป็นสิ่งที่สำคัญที่สุดได้

นอกจากนี้ ยังผสานรวมตั้งแต่ต้นกับส่วนอื่นๆ ของระบบนิเวศ Google Cloud ซึ่งรวมถึง Cloud SQL สำหรับฐานข้อมูลที่มีการจัดการ, Cloud Storage เพื่อพื้นที่เก็บข้อมูลออบเจ็กต์แบบรวม และ Secret Manager สำหรับจัดการข้อมูลลับ

Django เป็นเฟรมเวิร์กเว็บระดับสูงของ Python

ในบทแนะนำนี้ คุณจะใช้คอมโพเนนต์เหล่านี้ในการทำให้โปรเจ็กต์ Django ขนาดเล็กใช้งานได้

หมายเหตุ: Codelab นี้ได้รับการยืนยันครั้งล่าสุดกับ Django 5.0 Codelab นี้ควรทำงานต่อไป เว้นแต่จะมีการเปลี่ยนแปลงที่ส่งผลกับการอัปเดตในอนาคต ดูบันทึกประจำรุ่นของ Django ในอนาคต

สิ่งที่คุณจะได้เรียนรู้

วิธีใช้ Cloud Shell
วิธีสร้างฐานข้อมูล Cloud SQL
วิธีสร้างที่เก็บข้อมูล Cloud Storage
วิธีสร้างข้อมูลลับของ Secret Manager
วิธีใช้ข้อมูลลับจากบริการต่างๆ ของ Google Cloud
วิธีเชื่อมต่อคอมโพเนนต์ Google Cloud กับบริการ Cloud Run
วิธีใช้ Container Registry เพื่อจัดเก็บคอนเทนเนอร์ที่สร้างขึ้น
วิธีทำให้ใช้งานได้กับ Cloud Run
วิธีเรียกใช้การย้ายสคีมาฐานข้อมูลใน Cloud Build

2. การตั้งค่าและข้อกำหนด

การตั้งค่าสภาพแวดล้อมในแบบของคุณ

ลงชื่อเข้าใช้ Google Cloud Console แล้วสร้างโปรเจ็กต์ใหม่หรือใช้โปรเจ็กต์ที่มีอยู่ซ้ำ หากยังไม่มีบัญชี Gmail หรือ Google Workspace คุณต้องสร้างบัญชี

ชื่อโครงการคือชื่อที่แสดงของผู้เข้าร่วมโปรเจ็กต์นี้ ซึ่งเป็นสตริงอักขระที่ Google APIs ไม่ได้ใช้ คุณจะอัปเดตได้ทุกเมื่อ
รหัสโปรเจ็กต์จะไม่ซ้ำกันในทุกโปรเจ็กต์ของ Google Cloud และจะเปลี่ยนแปลงไม่ได้ (เปลี่ยนแปลงไม่ได้หลังจากตั้งค่าแล้ว) คอนโซล Cloud จะสร้างสตริงที่ไม่ซ้ำกันโดยอัตโนมัติ ซึ่งปกติแล้วคุณไม่จำเป็นต้องสนใจว่าสตริงนั้นจะเป็นอะไร ในโค้ดแล็บส่วนใหญ่ คุณจะต้องอ้างอิงรหัสโปรเจ็กต์ (ปกติจะระบุเป็น PROJECT_ID) หากไม่ชอบรหัสที่สร้างขึ้น คุณอาจสร้างรหัสอื่นแบบสุ่มได้ หรือจะลองใช้อุปกรณ์ของคุณเองเพื่อดูว่าอุปกรณ์พร้อมใช้งานหรือไม่ก็ได้ คุณจะเปลี่ยนแปลงหลังจากขั้นตอนนี้ไม่ได้และจะยังคงอยู่ตลอดระยะเวลาของโปรเจ็กต์
สำหรับข้อมูลของคุณ ค่าที่ 3 คือหมายเลขโปรเจ็กต์ ซึ่ง API บางตัวใช้ ดูข้อมูลเพิ่มเติมเกี่ยวกับค่าทั้ง 3 ค่าได้ในเอกสารประกอบ

ถัดไป คุณจะต้องเปิดใช้การเรียกเก็บเงินใน Cloud Console เพื่อใช้ทรัพยากร/API ของ Cloud การใช้งาน Codelab นี้จะไม่มีค่าใช้จ่ายใดๆ หากมี หากต้องการปิดทรัพยากรเพื่อหลีกเลี่ยงการเรียกเก็บเงินที่นอกเหนือจากบทแนะนำนี้ คุณสามารถลบทรัพยากรที่คุณสร้างหรือลบโปรเจ็กต์ได้ ผู้ใช้ Google Cloud ใหม่มีสิทธิ์เข้าร่วมโปรแกรมช่วงทดลองใช้ฟรี$300 USD

Google Cloud Shell

แม้ว่า Google Cloud จะทำงานจากระยะไกลจากแล็ปท็อปได้ แต่ในโค้ดแล็บนี้ เราจะใช้ Google Cloud Shell ซึ่งเป็นสภาพแวดล้อมบรรทัดคำสั่งที่ทำงานในระบบคลาวด์

เปิดใช้งาน Cloud Shell

จาก Cloud Console ให้คลิกเปิดใช้งาน Cloud Shell

หากนี่เป็นครั้งแรกที่คุณเริ่มใช้ Cloud Shell คุณจะเห็นหน้าจอกลางที่อธิบายเกี่ยวกับ Cloud Shell หากเห็นหน้าจอกลาง ให้คลิกต่อไป

การจัดสรรและเชื่อมต่อกับ Cloud Shell ใช้เวลาเพียงไม่กี่นาที

เครื่องเสมือนนี้โหลดเครื่องมือการพัฒนาที่จำเป็นทั้งหมดไว้แล้ว ซึ่งจะมีไดเรกทอรีหลักขนาด 5 GB ถาวรและทำงานใน Google Cloud ซึ่งจะช่วยเพิ่มประสิทธิภาพเครือข่ายและการรับรองได้อย่างมีประสิทธิภาพ คุณทํางานส่วนใหญ่ในโค้ดแล็บนี้ได้โดยใช้เบราว์เซอร์

เมื่อเชื่อมต่อกับ Cloud Shell แล้ว คุณควรเห็นการรับรองสิทธิ์และโปรเจ็กต์ที่ตั้งค่าเป็นรหัสโปรเจ็กต์ของคุณ

เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อยืนยันว่าคุณได้รับการตรวจสอบสิทธิ์แล้ว

gcloud auth list

เอาต์พุตจากคำสั่ง

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

หมายเหตุ: เครื่องมือบรรทัดคำสั่ง gcloud เป็นเครื่องมือบรรทัดคำสั่งแบบรวมที่มีประสิทธิภาพใน Google Cloud โดยจะติดตั้งมาล่วงหน้าใน Cloud Shell คุณจะเห็นว่าเครื่องมือนี้รองรับการเติมข้อความอัตโนมัติเมื่อกด Tab ระบบอาจแจ้งให้คุณตรวจสอบสิทธิ์เมื่อเรียกใช้คําสั่งเป็นครั้งแรก โปรดดูข้อมูลเพิ่มเติมที่หัวข้อภาพรวมของเครื่องมือบรรทัดคำสั่ง gcloud

เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อยืนยันว่าคำสั่ง gcloud รู้จักโปรเจ็กต์ของคุณ

gcloud config list project

เอาต์พุตจากคำสั่ง

[core]
project = <PROJECT_ID>

หากไม่เป็นเช่นนั้น ให้ตั้งค่าด้วยคําสั่งนี้

gcloud config set project <PROJECT_ID>

เอาต์พุตจากคำสั่ง

Updated property [core/project].

3. เปิดใช้ Cloud APIs

จาก Cloud Shell ให้เปิดใช้ Cloud API สําหรับคอมโพเนนต์ที่จะใช้

gcloud services enable \
  run.googleapis.com \
  sql-component.googleapis.com \
  sqladmin.googleapis.com \
  compute.googleapis.com \
  cloudbuild.googleapis.com \
  secretmanager.googleapis.com \
  artifactregistry.googleapis.com

เนื่องจากนี่เป็นการเรียก API จาก gcloud เป็นครั้งแรก ระบบจะขอให้คุณให้สิทธิ์ใช้ข้อมูลเข้าสู่ระบบเพื่อส่งคําขอนี้ ซึ่งจะเกิดขึ้น 1 ครั้งต่อเซสชัน Cloud Shell

การดำเนินการนี้อาจใช้เวลาสักครู่จึงจะเสร็จสมบูรณ์

เมื่อดำเนินการเสร็จแล้ว ข้อความสำเร็จที่คล้ายกับข้อความนี้ควรปรากฏขึ้น

Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.

4. สร้างโปรเจ็กต์เทมเพลต

คุณจะใช้เทมเพลตโปรเจ็กต์ Django เริ่มต้นเป็นโปรเจ็กต์ Django ตัวอย่าง

หากต้องการสร้างโปรเจ็กต์เทมเพลตนี้ ให้ใช้ Cloud Shell เพื่อสร้างไดเรกทอรีใหม่ชื่อ django-cloudrun แล้วไปที่ไดเรกทอรีดังกล่าว

mkdir ~/django-cloudrun
cd ~/django-cloudrun

จากนั้นติดตั้ง Django ในสภาพแวดล้อมเสมือนชั่วคราว โดยทำดังนี้

virtualenv venv
source venv/bin/activate
pip install Django

บันทึกรายการแพ็กเกจที่ติดตั้งลงใน requirements.txt

pip freeze > requirements.txt

รายการนี้ควรมี Django และไลบรารีที่ต้องพึ่งพา ได้แก่ sqlparse และ asgiref

จากนั้นสร้างโปรเจ็กต์เทมเพลตใหม่โดยทำดังนี้

django-admin startproject myproject .

คุณจะได้รับไฟล์ใหม่ชื่อ manage.py และโฟลเดอร์ใหม่ชื่อ myproject ซึ่งจะมีไฟล์จํานวนหนึ่ง รวมถึง settings.py

ตรวจสอบว่าเนื้อหาของโฟลเดอร์ระดับบนสุดเป็นไปตามที่คาดไว้

ls -F

manage.py myproject/ requirements.txt venv/

ตรวจสอบว่าเนื้อหาของโฟลเดอร์ myproject เป็นไปตามที่คาดไว้ ดังนี้

ls -F myproject/

__init__.py asgi.py settings.py  urls.py  wsgi.py

ตอนนี้คุณจะออกและนำสภาพแวดล้อมเสมือนชั่วคราวออกได้แล้ว ดังนี้

deactivate
rm -rf venv

จากที่นี่ ระบบจะเรียกใช้ Django ในคอนเทนเนอร์

5. สร้างบริการแบ็กเอนด์

ตอนนี้คุณกำลังสร้างบริการแบ็กเอนด์ ซึ่งได้แก่ บัญชีบริการเฉพาะ, Artifact Registry, ฐานข้อมูล Cloud SQL, ที่เก็บข้อมูล Cloud Storage และค่า Secret Manager จำนวนหนึ่ง

การรักษาความปลอดภัยในค่าของรหัสผ่านที่ใช้ในการทำให้ใช้งานได้มีความสำคัญต่อความปลอดภัยของโครงการทั้งหมด และช่วยให้มั่นใจว่าไม่มีใครใส่รหัสผ่านในที่ที่ไม่เหมาะสมโดยไม่ตั้งใจ (เช่น ใส่ในไฟล์การตั้งค่าโดยตรง หรือพิมพ์ลงในเทอร์มินัลโดยตรง ซึ่งสามารถดึงข้อมูลจากประวัติได้)

ในการเริ่มต้น ให้ตั้งค่าตัวแปรสภาพแวดล้อมพื้นฐาน 2 รายการ โดย 1 รายการสำหรับรหัสโปรเจ็กต์

PROJECT_ID=$(gcloud config get-value core/project)

และอีกตัวเลือกหนึ่งสำหรับภูมิภาคนี้คือ

REGION=us-central1

เมื่อทำงานกับโครงสร้างพื้นฐาน คุณควรวางคอมโพเนนต์ทั้งหมดไว้ในตำแหน่งเดียวกันเพื่อให้คอมโพเนนต์สื่อสารกันได้มีประสิทธิภาพมากขึ้น แม้ว่าคอมโพเนนต์บางอย่างจะพร้อมใช้งานทั่วโลก แต่คอมโพเนนต์บางรายการอาจไม่พร้อมใช้งานในบางภูมิภาค

สําหรับ Codelab นี้ เราขอแนะนําให้ใช้ us-central1, europe-north1 หรือ asia-northeast1 หรือภูมิภาคใดก็ได้ที่ Cloud Run (จัดการครบวงจร) รองรับ

ดูข้อมูลเพิ่มเติม

สร้างบัญชีบริการ

หากต้องการจำกัดสิทธิ์เข้าถึงที่บริการจะมีในส่วนอื่นๆ ของ Google Cloud ให้สร้างบัญชีบริการเฉพาะดังนี้

gcloud iam service-accounts create cloudrun-serviceaccount

คุณจะอ้างอิงบัญชีนี้ทางอีเมลในส่วนต่อๆ ไปของ Codelab นี้ ตั้งค่านั้นในตัวแปรสภาพแวดล้อม

SERVICE_ACCOUNT=$(gcloud iam service-accounts list \
    --filter cloudrun-serviceaccount --format "value(email)")

สร้าง Artifact Registry

หากต้องการจัดเก็บอิมเมจคอนเทนเนอร์ที่สร้างขึ้น ให้สร้างที่เก็บข้อมูลคอนเทนเนอร์ในภูมิภาคที่คุณเลือก โดยทำดังนี้

gcloud artifacts repositories create containers --repository-format docker --location $REGION

คุณจะอ้างอิงรีจิสทรีนี้ตามชื่อในส่วนต่อๆ ไปของ Codelab นี้:

ARTIFACT_REGISTRY=${REGION}-docker.pkg.dev/${PROJECT_ID}/containers

สร้างฐานข้อมูล

สร้างอินสแตนซ์ Cloud SQL

gcloud sql instances create myinstance --project $PROJECT_ID \
  --database-version POSTGRES_14 --tier db-f1-micro --region $REGION

การดำเนินการนี้อาจใช้เวลาสักครู่จึงจะเสร็จสมบูรณ์

ในอินสแตนซ์ดังกล่าว ให้สร้างฐานข้อมูลดังนี้

gcloud sql databases create mydatabase --instance myinstance

ในกรณีนี้ ให้สร้างผู้ใช้

DJPASS="$(cat /dev/urandom | LC_ALL=C tr -dc 'a-zA-Z0-9' | fold -w 30 | head -n 1)"
gcloud sql users create djuser --instance myinstance --password $DJPASS

ให้สิทธิ์บัญชีบริการเชื่อมต่อกับอินสแตนซ์ โดยทำดังนี้

gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member serviceAccount:${SERVICE_ACCOUNT} \
    --role roles/cloudsql.client

สร้างที่เก็บข้อมูล

สร้างที่เก็บข้อมูล Cloud Storage (โดยชื่อต้องไม่ซ้ำกันทั่วโลก)

GS_BUCKET_NAME=${PROJECT_ID}-media
gcloud storage buckets create gs://${GS_BUCKET_NAME} --location ${REGION}

ให้สิทธิ์บัญชีบริการเพื่อดูแลระบบที่เก็บข้อมูล โดยทำดังนี้

gcloud storage buckets add-iam-policy-binding gs://${GS_BUCKET_NAME} \
    --member serviceAccount:${SERVICE_ACCOUNT} \
    --role roles/storage.admin

จัดเก็บการกําหนดค่าเป็นข้อมูลลับ

เมื่อตั้งค่าบริการสนับสนุนแล้ว ตอนนี้คุณจะต้องจัดเก็บค่าเหล่านี้ไว้ในไฟล์ที่ได้รับการปกป้องโดยใช้ Secret Manager

Secret Manager ให้คุณจัดเก็บ จัดการ และเข้าถึงข้อมูลลับเป็น BLOB ไบนารีหรือสตริงข้อความ ซึ่งเหมาะสําหรับการจัดเก็บข้อมูลการกําหนดค่า เช่น รหัสผ่านฐานข้อมูล คีย์ API หรือใบรับรอง TLS ที่แอปพลิเคชันต้องใช้ในรันไทม์

ก่อนอื่น ให้สร้างไฟล์ที่มีค่าสำหรับสตริงการเชื่อมต่อฐานข้อมูลที่เก็บข้อมูลสื่อ คีย์ลับสําหรับ Django (ใช้สําหรับการรับรองการเข้ารหัสเซสชันและโทเค็น) และเพื่อเปิดใช้การแก้ไขข้อบกพร่อง

echo DATABASE_URL=\"postgres://djuser:${DJPASS}@//cloudsql/${PROJECT_ID}:${REGION}:myinstance/mydatabase\" > .env

echo GS_BUCKET_NAME=\"${GS_BUCKET_NAME}\" >> .env

echo SECRET_KEY=\"$(cat /dev/urandom | LC_ALL=C tr -dc 'a-zA-Z0-9' | fold -w 50 | head -n 1)\" >> .env

echo DEBUG=True >> .env

จากนั้นสร้างข้อมูลลับชื่อ application_settings โดยใช้ไฟล์ดังกล่าวเป็นข้อมูลลับ โดยทำดังนี้

gcloud secrets create application_settings --data-file .env

อนุญาตการเข้าถึงข้อมูลลับนี้แก่บัญชีบริการ:

gcloud secrets add-iam-policy-binding application_settings \
  --member serviceAccount:${SERVICE_ACCOUNT} --role roles/secretmanager.secretAccessor

ยืนยันว่าสร้างข้อมูลลับแล้วโดยแสดงรายการข้อมูลลับ

gcloud secrets versions list application_settings

หลังจากยืนยันว่าสร้างข้อมูลลับแล้ว ให้นำไฟล์ในเครื่องออกโดยทำดังนี้

rm .env

6. กำหนดค่าแอปพลิเคชัน

จากบริการสนับสนุนที่คุณเพิ่งสร้าง คุณจะต้องทำการเปลี่ยนแปลงบางอย่างในโปรเจ็กต์เทมเพลตตามความเหมาะสม

ซึ่งรวมถึงการแนะนํา django-environ ให้ใช้ตัวแปรสภาพแวดล้อมเป็นการตั้งค่าการกําหนดค่า ซึ่งคุณจะเริ่มต้นด้วยค่าที่คุณกําหนดเป็นข้อมูลลับ หากต้องการใช้การตั้งค่านี้ คุณต้องขยายการตั้งค่าเทมเพลต คุณจะต้องเพิ่มทรัพยากร Dependency ของ Python เพิ่มเติมด้วย

กำหนดการตั้งค่า

ย้ายไฟล์ settings.py และเปลี่ยนชื่อเป็น basesettings.py:

mv myproject/settings.py myproject/basesettings.py

ใช้เครื่องมือแก้ไขเว็บของ Cloud Shell เพื่อสร้างไฟล์ settings.py ใหม่โดยใช้โค้ดต่อไปนี้

touch myproject/settings.py
cloudshell edit myproject/settings.py

myproject/settings.py

import io
import os
from urllib.parse import urlparse

import environ

# Import the original settings from each template
from .basesettings import *

# Load the settings from the environment variable
env = environ.Env()
env.read_env(io.StringIO(os.environ.get("APPLICATION_SETTINGS", None)))

# Setting this value from django-environ
SECRET_KEY = env("SECRET_KEY")

# Ensure myproject is added to the installed applications
if "myproject" not in INSTALLED_APPS:
    INSTALLED_APPS.append("myproject")

# If defined, add service URLs to Django security settings
CLOUDRUN_SERVICE_URLS = env("CLOUDRUN_SERVICE_URLS", default=None)
if CLOUDRUN_SERVICE_URLS:
    CSRF_TRUSTED_ORIGINS = env("CLOUDRUN_SERVICE_URLS").split(",")
    # Remove the scheme from URLs for ALLOWED_HOSTS
    ALLOWED_HOSTS = [urlparse(url).netloc for url in CSRF_TRUSTED_ORIGINS]
else:
    ALLOWED_HOSTS = ["*"]

# Default false. True allows default landing pages to be visible
DEBUG = env("DEBUG", default=False)

# Set this value from django-environ
DATABASES = {"default": env.db()}

# Change database settings if using the Cloud SQL Auth Proxy
if os.getenv("USE_CLOUD_SQL_AUTH_PROXY", None):
    DATABASES["default"]["HOST"] = "127.0.0.1"
    DATABASES["default"]["PORT"] = 5432

# Define static storage via django-storages[google]
GS_BUCKET_NAME = env("GS_BUCKET_NAME")
STATICFILES_DIRS = []
GS_DEFAULT_ACL = "publicRead"
STORAGES = {
    "default": {
        "BACKEND": "storages.backends.gcloud.GoogleCloudStorage",
    },
    "staticfiles": {
        "BACKEND": "storages.backends.gcloud.GoogleCloudStorage",
    },
}

โปรดสละเวลาอ่านความคิดเห็นที่เพิ่มเข้าไปเกี่ยวกับการกำหนดค่าแต่ละรายการ

โปรดทราบว่าคุณอาจเห็นข้อผิดพลาดของโปรแกรมวิเคราะห์โค้ดในไฟล์นี้ กรณีนี้เป็นสิ่งที่คาดว่าจะเกิดอยู่แล้ว Cloud Shell ไม่มีบริบทสำหรับข้อกำหนดสำหรับโปรเจ็กต์นี้ จึงอาจรายงานการนำเข้าที่ไม่ถูกต้องและการนำเข้าที่ไม่ได้ใช้

ทรัพยากร Dependency ของ Python

ค้นหาไฟล์ requirements.txt แล้วเพิ่มแพ็กเกจต่อไปนี้ต่อท้าย

cloudshell edit requirements.txt

requirements.txt (ต่อท้าย)

gunicorn
psycopg2-binary
django-storages[google]
django-environ

กำหนดอิมเมจของแอปพลิเคชัน

Cloud Run จะเรียกใช้คอนเทนเนอร์ทั้งหมดตราบใดที่เป็นไปตามสัญญาคอนเทนเนอร์ Cloud Run บทแนะนํานี้จะเลือกไม่ใช้ Dockerfile แต่จะใช้ Cloud Native Buildpacks แทน Buildpack ช่วยในการสร้างคอนเทนเนอร์สำหรับภาษาทั่วไป ซึ่งรวมถึง Python

บทแนะนํานี้จะเลือกปรับแต่ง Procfile ที่ใช้เพื่อเริ่มเว็บแอปพลิเคชัน

หากต้องการสร้างโปรเจ็กต์เทมเพลตโดยใช้คอนเทนเนอร์ ก่อนอื่นให้สร้างไฟล์ใหม่ชื่อ Procfile ที่ระดับบนสุดของโปรเจ็กต์ (ในไดเรกทอรีเดียวกับ manage.py) แล้วคัดลอกเนื้อหาต่อไปนี้

touch Procfile
cloudshell edit Procfile

Procfile

web: gunicorn --bind 0.0.0.0:$PORT --workers 1 --threads 8 --timeout 0 myproject.wsgi:application

7. กำหนดค่า บิลด์ และเรียกใช้ขั้นตอนการย้ายข้อมูล

หากต้องการสร้างสคีมาของฐานข้อมูลในฐานข้อมูล Cloud SQL และเติมข้อมูลให้ที่เก็บข้อมูล Cloud Storage ด้วยเนื้อหาแบบคงที่ คุณต้องเรียกใช้ migrate และ collectstatic

คำสั่งการย้ายข้อมูล Django พื้นฐานเหล่านี้ต้องเรียกใช้ภายในบริบทของอิมเมจคอนเทนเนอร์ที่สร้างซึ่งมีสิทธิ์เข้าถึงฐานข้อมูล

นอกจากนี้ คุณจะต้องเรียกใช้ createsuperuser เพื่อสร้างบัญชีผู้ดูแลระบบเพื่อเข้าสู่ระบบผู้ดูแลระบบ Django ด้วย

โดยคุณจะใช้ Cloud Run Jobs เพื่อดําเนินการเหล่านี้ งาน Cloud Run ช่วยให้คุณเรียกใช้กระบวนการที่มีจุดสิ้นสุดที่กําหนดไว้ได้ จึงเหมาะสําหรับงานการดูแลระบบ

กำหนดรหัสผ่านผู้ใช้ที่ดูแลระบบ Django

หากต้องการสร้างผู้ใช้ที่ดูแลระบบ คุณจะใช้คำสั่ง createsuperuser เวอร์ชันที่ไม่มีการโต้ตอบ คำสั่งนี้ต้องใช้ตัวแปรสภาพแวดล้อมที่มีชื่อพิเศษเพื่อใช้แทนพรอมต์ให้ป้อนรหัสผ่าน

สร้างข้อมูลลับใหม่โดยใช้รหัสผ่านที่สร้างขึ้นแบบสุ่ม โดยทำดังนี้

echo -n $(cat /dev/urandom | LC_ALL=C tr -dc 'a-zA-Z0-9' | fold -w 30 | head -n 1) | gcloud secrets create django_superuser_password --data-file=-

อนุญาตให้บัญชีบริการเข้าถึงข้อมูลลับนี้

gcloud secrets add-iam-policy-binding django_superuser_password \
  --member serviceAccount:${SERVICE_ACCOUNT} \
  --role roles/secretmanager.secretAccessor

อัปเดต Procfile

หากต้องการให้งาน Cloud Run มีความชัดเจน ให้สร้างทางลัดใน Procfile โดยเพิ่มจุดแรกเข้าต่อไปนี้ต่อท้าย Procfile

migrate: python manage.py migrate && python manage.py collectstatic --noinput --clear
createuser: python manage.py createsuperuser --username admin --email noop@example.com --noinput

ตอนนี้คุณควรมี 3 รายการ ได้แก่ จุดแรกเข้า web เริ่มต้น, จุดเข้าถึง migrate เพื่อใช้การย้ายข้อมูลฐานข้อมูล และรายการจุดเข้า createuser เพื่อเรียกใช้คำสั่ง createsuperuser

สร้างรูปภาพแอปพลิเคชัน

เมื่ออัปเดต Procfile แล้ว ให้สร้างภาพโดยทำดังนี้

gcloud builds submit --pack image=${ARTIFACT_REGISTRY}/myimage

สร้างงาน Cloud Run

เนื่องจากมีอิมเมจดังกล่าวอยู่แล้ว คุณจึงสร้างงาน Cloud Run โดยใช้อิมเมจดังกล่าวได้

งานเหล่านี้ใช้ภาพที่สร้างขึ้นก่อนหน้านี้ แต่ใช้ค่า command ที่แตกต่างกัน ค่าเหล่านี้จะแมปกับค่าใน Procfile

สร้างงานสําหรับการย้ายข้อมูล

gcloud run jobs create migrate \
  --region $REGION \
  --image ${ARTIFACT_REGISTRY}/myimage \
  --set-cloudsql-instances ${PROJECT_ID}:${REGION}:myinstance \
  --set-secrets APPLICATION_SETTINGS=application_settings:latest \
  --service-account $SERVICE_ACCOUNT \
  --command migrate

สร้างงานสำหรับการสร้างผู้ใช้:

gcloud run jobs create createuser \
  --region $REGION \
  --image ${ARTIFACT_REGISTRY}/myimage \
  --set-cloudsql-instances ${PROJECT_ID}:${REGION}:myinstance \
  --set-secrets APPLICATION_SETTINGS=application_settings:latest \
  --set-secrets DJANGO_SUPERUSER_PASSWORD=django_superuser_password:latest \
  --service-account $SERVICE_ACCOUNT \
  --command createuser

เรียกใช้งาน Cloud Run

เมื่อกำหนดค่างานแล้ว ให้เรียกใช้การย้ายข้อมูล

gcloud run jobs execute migrate --region $REGION --wait

ตรวจสอบว่าเอาต์พุตของคำสั่งนี้ระบุว่าการดำเนินการ "เสร็จสมบูรณ์"

คุณจะต้องเรียกใช้คําสั่งนี้ในภายหลังเมื่ออัปเดตแอปพลิเคชัน

เมื่อตั้งค่าฐานข้อมูลแล้ว ให้สร้างผู้ใช้โดยใช้งานดังนี้

gcloud run jobs execute createuser --region $REGION --wait

ตรวจสอบว่าเอาต์พุตของคำสั่งนี้ระบุว่าการดำเนินการ "เสร็จสมบูรณ์"

คุณจะไม่จําเป็นต้องเรียกใช้คําสั่งนี้อีก

8. ทำให้ใช้งานได้กับ Cloud Run

เมื่อสร้างและป้อนข้อมูลบริการสนับสนุนแล้ว ตอนนี้คุณก็สร้างบริการ Cloud Run เพื่อเข้าถึงบริการเหล่านั้นได้

ทำให้บริการใช้งานได้กับ Cloud Run โดยใช้อิมเมจที่คุณสร้างไว้ก่อนหน้านี้ด้วยคำสั่งต่อไปนี้

gcloud run deploy django-cloudrun \
  --region $REGION \
  --image ${ARTIFACT_REGISTRY}/myimage \
  --set-cloudsql-instances ${PROJECT_ID}:${REGION}:myinstance \
  --set-secrets APPLICATION_SETTINGS=application_settings:latest \
  --service-account $SERVICE_ACCOUNT \
  --allow-unauthenticated

หากดำเนินการสำเร็จ บรรทัดคำสั่งจะแสดง URL ของบริการดังนี้

Service [django-cloudrun] revision [django-cloudrun-00001-...] has been deployed and is serving 100 percent of traffic.
Service URL: https://django-cloudrun-...run.app

ตอนนี้คุณเข้าชมคอนเทนเนอร์ที่ติดตั้งใช้งานแล้วได้โดยเปิด URL นี้ในเว็บเบราว์เซอร์

9. การเข้าถึงผู้ดูแลระบบ Django

คุณลักษณะหลักอย่างหนึ่งของ Django คือการดูแลระบบแบบอินเทอร์แอกทีฟ

อัปเดตการตั้งค่า CSRF

Django มีการป้องกันการปลอมแปลงคําขอข้ามเว็บไซต์ (CSRF) ทุกครั้งที่มีการส่งแบบฟอร์มในเว็บไซต์ Django รวมถึงการเข้าสู่ระบบผู้ดูแลระบบ Django ระบบจะเลือกการตั้งค่าต้นทางที่เชื่อถือได้ หากไม่ตรงกับต้นทางของคำขอ Django จะแสดงข้อผิดพลาด

ในไฟล์ mysite/settings.py หากกำหนดตัวแปรสภาพแวดล้อม CLOUDRUN_SERVICE_URL ไว้ ระบบจะใช้ตัวแปรดังกล่าวในการตั้งค่า CSRF_TRUSTED_ORIGINS และ ALLOWED_HOSTS แม้ว่าการกำหนด ALLOWED_HOSTS จะไม่บังคับ แต่คุณควรเพิ่ม ALLOWED_HOSTS เนื่องจาก CSRF_TRUSTED_ORIGINS จำเป็นต้องมีอยู่แล้ว

เนื่องจากคุณต้องใช้ URL ของบริการ คุณจึงเพิ่มการกําหนดค่านี้ไม่ได้จนกว่าจะทําการติดตั้งใช้งานครั้งแรก

คุณจะต้องอัปเดตบริการเพื่อเพิ่มตัวแปรสภาพแวดล้อมนี้ โดยอาจเพิ่มลงในข้อมูลลับ application_settings หรือเพิ่มเป็นตัวแปรสภาพแวดล้อมโดยตรง

การใช้งานด้านล่างใช้ประโยชน์จากการจัดรูปแบบและการหลีกของ gcloud

เรียกข้อมูล URL ของบริการ

CLOUDRUN_SERVICE_URLS=$(gcloud run services describe django-cloudrun \
  --region $REGION  \
  --format "value(metadata.annotations[\"run.googleapis.com/urls\"])" | tr -d '"[]')
echo $CLOUDRUN_SERVICE_URLS

ตั้งค่านี้เป็นตัวแปรสภาพแวดล้อมในบริการ Cloud Run ดังนี้

gcloud run services update django-cloudrun \
  --region $REGION \
  --update-env-vars "^##^CLOUDRUN_SERVICE_URLS=$CLOUDRUN_SERVICE_URLS"

การเข้าสู่ระบบ Django Admin

หากต้องการเข้าถึงอินเทอร์เฟซผู้ดูแลระบบ Django ให้เพิ่ม /admin ต่อท้าย URL ของบริการ

ในตอนนี้ให้เข้าสู่ระบบด้วยชื่อผู้ใช้ "admin" และเรียกดูรหัสผ่านของคุณโดยใช้คำสั่งต่อไปนี้:

gcloud secrets versions access latest --secret django_superuser_password && echo ""

10. การพัฒนาแอปพลิเคชันของคุณ

ขณะพัฒนาแอปพลิเคชัน คุณจะต้องทดสอบแอปพลิเคชันนั้นในเครื่อง โดยคุณจะต้องเชื่อมต่อกับฐานข้อมูล Cloud SQL ("เวอร์ชันที่ใช้งานจริง") หรือฐานข้อมูลในเครื่อง ("ทดสอบ")

เชื่อมต่อกับฐานข้อมูลเวอร์ชันที่ใช้งานจริง

คุณสามารถเชื่อมต่อกับอินสแตนซ์ Cloud SQL โดยใช้พร็อกซีการตรวจสอบสิทธิ์ Cloud SQL แอปพลิเคชันนี้จะสร้างการเชื่อมต่อจากเครื่องของคุณเองไปยังฐานข้อมูล

เมื่อติดตั้งพร็อกซีการตรวจสอบสิทธิ์ Cloud SQL แล้ว ให้ทำตามขั้นตอนต่อไปนี้

# Create a virtualenv
virtualenv venv
source venv/bin/activate
pip install -r requirements.txt

# Copy the application settings to your local machine
gcloud secrets versions access latest --secret application_settings > temp_settings

# Run the Cloud SQL Auth Proxy
./cloud-sql-proxy --instances=${PROJECT_ID}:${REGION}:myinstance=tcp:5432

# In a new tab, start the local web server using these new settings
USE_CLOUD_SQL_AUTH_PROXY=true APPLICATION_SETTINGS=$(cat temp_settings) python manage.py runserver

อย่าลืมนำไฟล์ temp_settings ออกเมื่อทำงานเสร็จแล้ว

เชื่อมต่อกับฐานข้อมูล SQLite ในเครื่อง

หรือจะใช้ฐานข้อมูลในเครื่องเมื่อพัฒนาแอปพลิเคชันก็ได้ Django รองรับทั้งฐานข้อมูล PostgreSQL และ SQLite และมีฟีเจอร์บางอย่างที่ PostgreSQL มีแต่ SQLite ไม่มี แต่ในกรณีส่วนใหญ่ ฟังก์ชันการทำงานจะเหมือนกัน

หากต้องการตั้งค่า SQLite คุณจะต้องอัปเดตการตั้งค่าแอปพลิเคชัน ให้ชี้ไปที่ฐานข้อมูลในเครื่อง จากนั้นต้องใช้การย้ายข้อมูลสคีมา

วิธีตั้งค่าวิธีการนี้

# Create a virtualenv
virtualenv venv
source venv/bin/activate
pip install -r requirements.txt

# Copy the application settings to your local machine
gcloud secrets versions access latest --secret application_settings > temp_settings

# Edit the DATABASE_URL setting to use a local sqlite file. For example:
DATABASE_URL=sqlite:////tmp/my-tmp-sqlite.db

# Set the updated settings as an environment variable
APPLICATION_SETTINGS=$(cat temp_settings) 

# Apply migrations to the local database
python manage.py migrate

# Start the local web server
python manage.py runserver

อย่าลืมนำไฟล์ temp_settings ออกหลังจากทำงานเสร็จแล้ว

การสร้างการย้ายข้อมูล

เมื่อทำการเปลี่ยนแปลงโมเดลฐานข้อมูล คุณอาจต้องสร้างไฟล์การย้ายข้อมูลของ Django โดยเรียกใช้ python manage.py makemigrations

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

SECRET_KEY="" DATABASE_URL="" GS_BUCKET_NAME="" python manage.py makemigrations

การใช้การอัปเดตแอปพลิเคชัน

หากต้องการใช้การเปลี่ยนแปลงกับแอปพลิเคชัน คุณจะต้องดำเนินการต่อไปนี้

สร้างการเปลี่ยนแปลงเป็นรูปภาพใหม่
ใช้ฐานข้อมูลหรือการย้ายข้อมูลแบบคงที่
อัปเดตบริการ Cloud Run ให้ใช้อิมเมจใหม่

วิธีสร้างอิมเมจ

gcloud builds submit --pack image=${ARTIFACT_REGISTRY}/myimage

หากคุณมีการย้ายข้อมูลที่ต้องการใช้ ให้เรียกใช้งาน Cloud Run ดังนี้

gcloud run jobs execute migrate --region $REGION --wait

วิธีอัปเดตบริการด้วยรูปภาพใหม่

gcloud run services update django-cloudrun \
  --region $REGION \
  --image ${ARTIFACT_REGISTRY}/myimage

11. ยินดีด้วย

คุณเพิ่งทำให้โปรเจ็กต์ที่ซับซ้อนใช้งานได้กับ Cloud Run

Cloud Run จะปรับขนาดอิมเมจคอนเทนเนอร์โดยอัตโนมัติและในแนวนอนเพื่อจัดการคำขอที่ได้รับ จากนั้นจึงลดขนาดลงเมื่อความต้องการลดลง คุณจะต้องชำระค่าบริการตามการใช้งาน CPU, หน่วยความจำ และเครือข่ายระหว่างการจัดการคำขอเท่านั้น
Cloud SQL ช่วยให้คุณจัดสรรอินสแตนซ์ PostgreSQL ที่มีการจัดการซึ่งจะได้รับการบำรุงรักษาโดยอัตโนมัติ และผสานรวมกับระบบต่างๆ ของ Google Cloud ได้อย่างราบรื่น
Cloud Storage ช่วยให้คุณมีพื้นที่เก็บข้อมูลระบบคลาวด์ในลักษณะที่เข้าถึงได้อย่างราบรื่นใน Django
เครื่องมือจัดการข้อมูลลับช่วยให้คุณจัดเก็บข้อมูลลับและกำหนดให้เข้าถึงได้เฉพาะส่วนต่างๆ ของ Google Cloud เท่านั้น

ล้างข้อมูล

โปรดทำดังนี้เพื่อเลี่ยงไม่ให้เกิดการเรียกเก็บเงินกับบัญชี Google Cloud Platform สำหรับทรัพยากรที่ใช้ในบทแนะนำนี้

ใน Cloud Console ให้ไปที่หน้าจัดการทรัพยากร
ในรายการโปรเจ็กต์ ให้เลือกโปรเจ็กต์ของคุณ แล้วคลิกลบ
ในกล่องโต้ตอบ ให้พิมพ์รหัสโปรเจ็กต์ แล้วคลิกปิดเพื่อลบโปรเจ็กต์

ดูข้อมูลเพิ่มเติม

Django ใน Cloud Run: https://cloud.google.com/python/django/run
สวัสดี Cloud Run ด้วย Python: https://codelabs.developers.google.com/codelabs/cloud-run-hello-python3
Python บน Google Cloud: https://cloud.google.com/python
ไคลเอ็นต์ Python ของ Google Cloud: https://github.com/googleapis/google-cloud-python