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

Django CMS บน Cloud Run

1. บทนำ

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

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

Django CMS เป็นระบบจัดการเนื้อหา (CMS) ระดับองค์กรที่สร้างขึ้นบน Django Django เป็นเว็บเฟรมเวิร์ก Python ระดับสูง

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

หมายเหตุ: Codelab นี้ได้รับการยืนยันล่าสุดด้วย Django CMS 4.1.2 ถึง django-cms/cms-template v4.1

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

วิธีใช้ 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 Console จะสร้างสตริงที่ไม่ซ้ำกันโดยอัตโนมัติ คือคุณไม่สนว่าอะไรเป็นอะไร ใน Codelab ส่วนใหญ่ คุณจะต้องอ้างอิงรหัสโปรเจ็กต์ (โดยปกติจะระบุเป็น PROJECT_ID) หากคุณไม่ชอบรหัสที่สร้างขึ้น คุณสามารถสร้างรหัสอื่นแบบสุ่มได้ หรือคุณจะลองดำเนินการเองแล้วดูว่าพร้อมให้ใช้งานหรือไม่ คุณจะเปลี่ยนแปลงหลังจากขั้นตอนนี้ไม่ได้และจะยังคงอยู่ตลอดระยะเวลาของโปรเจ็กต์
โปรดทราบว่ามีค่าที่ 3 ซึ่งเป็นหมายเลขโปรเจ็กต์ที่ API บางรายการใช้ ดูข้อมูลเพิ่มเติมเกี่ยวกับค่าทั้ง 3 รายการนี้ได้ในเอกสารประกอบ

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

Google Cloud Shell

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

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

จาก Cloud Console ให้คลิกเปิดใช้งาน 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 คุณจะเห็นการรองรับการใช้งานแท็บเสร็จสมบูรณ์ ระบบอาจแจ้งให้คุณตรวจสอบสิทธิ์เมื่อเรียกใช้คําสั่งเป็นครั้งแรก โปรดดูข้อมูลเพิ่มเติมที่หัวข้อภาพรวมของเครื่องมือบรรทัดคำสั่ง gcloud

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

gcloud config list project

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

[core]
project = <PROJECT_ID>

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

gcloud config set project <PROJECT_ID>

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

Updated property [core/project].

3. เปิดใช้ Cloud API

จาก 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. สร้างโปรเจ็กต์เทมเพลต

คุณจะใช้ cms-template ของ Django CMS เป็นโปรเจ็กต์ CMS ของ Django

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

mkdir ~/djangocms-cloudrun
cd ~/djangocms-cloudrun

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

virtualenv venv
source venv/bin/activate
pip install djangocms-frontend\[cms-4]

สร้างสำเนาของโปรเจ็กต์เทมเพลต cms:

django-admin startproject --template https://github.com/django-cms/cms-template/archive/4.1.zip myproject .

ตอนนี้คุณจะมีโปรเจ็กต์ Django CMS เทมเพลตในโฟลเดอร์ชื่อ myproject

ls -F

manage.py*  media/  myproject/  project.db  requirements.in requirements.txt  static/ venv/

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

deactivate
rm -rf venv

จากตรงนี้ ระบบจะเรียกใช้ Django CMS ภายในคอนเทนเนอร์

นอกจากนี้ คุณยังนำไฟล์ requirements.in ที่คัดลอกโดยอัตโนมัติออกได้ด้วย (ไฟล์นี้ใช้โดย pip-tools เพื่อสร้างไฟล์ requirements.txt) จะไม่ใช้สำหรับ Codelab นี้

rm requirements.in

5. สร้างบริการสำรอง

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

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

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

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

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

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

สร้างรีจิสทรีอาร์ติแฟกต์

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

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

เนื่องจากออบเจ็กต์ที่จัดเก็บในที่เก็บข้อมูลจะมีต้นทางอื่น (URL ของที่เก็บข้อมูลแทน URL ของ Cloud Run) คุณจึงต้องกำหนดการตั้งค่าการแชร์ทรัพยากรข้ามโดเมน (CORS)

สร้างไฟล์ใหม่ชื่อ cors.json โดยมีเนื้อหาดังนี้

touch cors.json
cloudshell edit cors.json

cors.json

[
    {
      "origin": ["*"],
      "responseHeader": ["Content-Type"],
      "method": ["GET"],
      "maxAgeSeconds": 3600
    }
]

ใช้การกําหนดค่า CORS นี้กับที่เก็บข้อมูลที่สร้างขึ้นใหม่

gsutil cors set cors.json gs://$GS_BUCKET_NAME

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

เมื่อตั้งค่าบริการสนับสนุนแล้ว ตอนนี้คุณจะต้องจัดเก็บค่าเหล่านี้ไว้ในไฟล์ที่ได้รับการปกป้องโดยใช้ 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 Buildpack แทน 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

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

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 djangocms-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 [djangocms-cloudrun] revision [djangocms-cloudrun-00001-...] has been deployed and is serving 100 percent of traffic.
Service URL: https://djangocms-cloudrun-...run.app

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

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

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

หนึ่งในฟีเจอร์หลักของ Django CMS คือการดูแลระบบแบบอินเทอร์แอกทีฟ

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

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

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

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

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

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

ดึงข้อมูล URL บริการของคุณ:

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

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

gcloud run services update djangocms-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 ${PROJECT_ID}:${REGION}:myinstance

# 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 djangocms-cloudrun \
  --platform managed \
  --region $REGION \
  --image gcr.io/${PROJECT_ID}/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