इस पेज का अनुवाद Cloud Translation API से किया गया है.

Cloud Run पर Django CMS

1. परिचय

Cloud Run एक मैनेज किया जाने वाला कंप्यूट प्लैटफ़ॉर्म है. इसकी मदद से, स्टेटलेस कंटेनर चलाए जा सकते हैं. इन्हें एचटीटीपी अनुरोधों की मदद से चालू किया जा सकता है. Cloud Run बिना सर्वर वाली सेवा है: यह इन्फ़्रास्ट्रक्चर मैनेजमेंट को अलग रखता है, ताकि आप सबसे अहम ऐप्लिकेशन बनाने पर फ़ोकस कर सकें.

यह Google Cloud नेटवर्क के कई अन्य हिस्सों के साथ भी इंटरफ़ेस करता है. इनमें मैनेज किए जा रहे डेटाबेस के लिए Cloud SQL, यूनिफ़ाइड ऑब्जेक्ट स्टोरेज के लिए Cloud Storage, और सीक्रेट मैनेज करने के लिए सीक्रेट मैनेजर शामिल हैं.

Django CMS, Django पर आधारित एक एंटरप्राइज़ कॉन्टेंट मैनेजमेंट सिस्टम (सीएमएस) है. Django, Python का एक हाई-लेवल वेब फ़्रेमवर्क है.

इस ट्यूटोरियल में, Django CMS से जुड़े एक छोटे प्रोजेक्ट को डिप्लॉय करने के लिए, इन कॉम्पोनेंट का इस्तेमाल किया जाएगा.

ध्यान दें: इस कोडलैब की पुष्टि पिछली बार django-cms/cms-template v4.1 की मदद से, Django CMS 4.1.2 के साथ की गई थी.

आपको इनके बारे में जानकारी मिलेगी

Cloud Shell का इस्तेमाल करने का तरीका
Cloud SQL डेटाबेस बनाने का तरीका
Cloud Storage बकेट बनाने का तरीका
सीक्रेट मैनेजर सीक्रेट बनाने का तरीका
Google Cloud की अलग-अलग सेवाओं के सीक्रेट इस्तेमाल करने का तरीका
Google Cloud के कॉम्पोनेंट को Cloud Run सेवा से कनेक्ट करने का तरीका
बने हुए कंटेनर को सेव करने के लिए, Container Registry का इस्तेमाल करने का तरीका
Cloud Run पर डिप्लॉय करने का तरीका
Cloud Build में डेटाबेस स्कीमा माइग्रेशन चलाने का तरीका

2. सेटअप और ज़रूरी शर्तें

अपने हिसाब से एनवायरमेंट सेट अप करना

Google Cloud Console में साइन इन करें और नया प्रोजेक्ट बनाएं या किसी मौजूदा प्रोजेक्ट का फिर से इस्तेमाल करें. अगर आपके पास पहले से कोई Gmail या Google Workspace खाता नहीं है, तो आपको एक खाता बनाना होगा.

प्रोजेक्ट का नाम, इस प्रोजेक्ट में हिस्सा लेने वाले लोगों के लिए डिसप्ले नेम होता है. यह एक वर्ण स्ट्रिंग है, जिसका इस्तेमाल Google API नहीं करता. इसे कभी भी अपडेट किया जा सकता है.
प्रोजेक्ट आईडी Google Cloud के सभी प्रोजेक्ट के लिए यूनीक होता है. साथ ही, इसे बदला नहीं जा सकता. इसे सेट करने के बाद बदला नहीं जा सकता. Cloud Console, अपने-आप एक यूनीक स्ट्रिंग जनरेट करता है. आम तौर पर, आपको यह जानने की ज़रूरत नहीं होती कि यह स्ट्रिंग क्या है. ज़्यादातर कोडलैब में, आपको अपने प्रोजेक्ट आईडी का रेफ़रंस देना होगा. आम तौर पर, इसे PROJECT_ID के तौर पर पहचाना जाता है. अगर आपको जनरेट किया गया आईडी पसंद नहीं आता है, तो कोई दूसरा आईडी जनरेट किया जा सकता है. इसके अलावा, आपके पास खुद का कोई दूसरा नाम चुनने का विकल्प भी है. इस चरण के बाद, इसे बदला नहीं जा सकता. यह प्रोजेक्ट के दौरान बना रहता है.
आपकी जानकारी के लिए बता दें कि तीसरी वैल्यू, प्रोजेक्ट नंबर होती है. इसका इस्तेमाल कुछ एपीआई करते हैं. दस्तावेज़ में इन तीनों वैल्यू के बारे में ज़्यादा जानें.

इसके बाद, आपको क्लाउड संसाधनों/एपीआई का इस्तेमाल करने के लिए, Cloud Console में बिलिंग चालू करनी होगी. इस कोडलैब का इस्तेमाल करने पर, आपको ज़्यादा पैसे नहीं चुकाने होंगे. इस ट्यूटोरियल के अलावा, बिलिंग से बचने के लिए संसाधनों को बंद करें. इसके लिए, अपने बनाए गए संसाधनों को मिटाएं या प्रोजेक्ट को मिटाएं. Google Cloud के नए उपयोगकर्ता, 300 डॉलर के मुफ़्त ट्रायल वाले प्रोग्राम में हिस्सा ले सकते हैं.

Google Cloud Shell

Google Cloud को आपके लैपटॉप से, कहीं से भी ऑपरेट किया जा सकता है. हालांकि, इस कोडलैब में हम Google Cloud Shell का इस्तेमाल करेंगे. यह क्लाउड में चलने वाला कमांड लाइन एनवायरमेंट है.

Cloud Shell चालू करें

Cloud Console में, Cloud Shell चालू करें पर क्लिक करें.

अगर आपने Cloud Shell का इस्तेमाल पहली बार किया है, तो आपको बीच में आने वाली स्क्रीन दिखेगी. इसमें यह बताया जाएगा कि यह क्या है. अगर आपको बीच के लेवल पर मिलने वाली स्क्रीन दिखती है, तो जारी रखें पर क्लिक करें.

Cloud Shell को प्रोवाइड करने और उससे कनेक्ट करने में सिर्फ़ कुछ मिनट लगेंगे.

इस वर्चुअल मशीन में, डेवलपमेंट के लिए ज़रूरी सभी टूल लोड होते हैं. इसमें लगातार पांच जीबी की होम डायरेक्ट्री मिलती है और यह 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 कमांड को आपके प्रोजेक्ट के बारे में पता है या नहीं, इसकी पुष्टि करने के लिए Cloud Shell में यह कमांड चलाएं:

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

पहली बार gcloud से एपीआई को कॉल किया जा रहा है. इसलिए, यह अनुरोध करने के लिए, आपसे अपने क्रेडेंशियल का इस्तेमाल करने की अनुमति मांगी जाएगी. ऐसा हर Cloud Shell सेशन में एक बार होगा.

इस प्रोसेस को पूरा होने में कुछ समय लग सकता है.

फ़ॉर्म भरने के बाद, इस मैसेज से मिलता-जुलता मैसेज दिखेगा:

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

4. टेंप्लेट प्रोजेक्ट बनाना

आपको Django सीएमएस प्रोजेक्ट के सैंपल के तौर पर, Django सीएमएस cms-template का इस्तेमाल करना होगा.

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 .

अब आपके पास myproject नाम के फ़ोल्डर में एक Django CMS प्रोजेक्ट होगा:

ls -F

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

अब आपके पास, अस्थायी वर्चुअल एनवायरमेंट से बाहर निकलने और उसे हटाने का विकल्प है:

deactivate
rm -rf venv

यहां से, कंटेनर के अंदर Django CMS को कॉल किया जाएगा.

अपने-आप कॉपी होने वाली criteria.in फ़ाइल को भी हटाया जा सकता है. pip-tools का इस्तेमाल करके, Essentials.txt फ़ाइलें जनरेट की जा सकती हैं. इसका इस्तेमाल इस कोडलैब के लिए नहीं किया जाएगा:

rm requirements.in

5. बैकिंग सेवाएं बनाना

अब आपको अपनी बैकिंग सेवाएं बनानी होंगी: एक खास सेवा खाता, Artifact Registry, Cloud SQL डेटाबेस, Cloud Storage बकेट, और कई Secret Manager वैल्यू.

डिप्लॉयमेंट में इस्तेमाल किए गए पासवर्ड की वैल्यू को सुरक्षित रखना, किसी भी प्रोजेक्ट की सुरक्षा के लिए अहम होता है. साथ ही, यह पक्का करता है कि कोई भी व्यक्ति गलती से उस जगह पर न डाले जहां वह नहीं है. उदाहरण के लिए, सीधे सेटिंग फ़ाइलों में या सीधे आपके टर्मिनल में टाइप करने पर, जहां उसे इतिहास से वापस लाया जा सकता हो.

शुरू करने के लिए, दो बेस एनवायरमेंट वैरिएबल सेट करें. पहला, प्रोजेक्ट आईडी के लिए:

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

और एक देश/इलाके के लिए:

REGION=us-central1

इन्फ़्रास्ट्रक्चर के साथ काम करते समय, सभी कॉम्पोनेंट का एक ही जगह पर होना बेहतर होता है. इससे ये कॉम्पोनेंट एक-दूसरे के साथ बेहतर तरीके से बात कर पाते हैं. कुछ कॉम्पोनेंट दुनिया भर में उपलब्ध होते हैं, लेकिन सभी कॉम्पोनेंट सभी क्षेत्रों में उपलब्ध नहीं होते.

हमारा सुझाव है कि इस कोडलैब के लिए, 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)")

Artifact Registry बनाना

बनाई गई कंटेनर इमेज को सेव करने के लिए, चुने गए इलाके में कंटेनर रजिस्ट्री बनाएं:

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

इस कोडलैब के आगे के सेक्शन में, आपको इस रजिस्ट्री का नाम बताना होगा:

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

बकेट में सेव किए गए ऑब्जेक्ट का ऑरिजिन अलग होगा. यह Cloud Run यूआरएल के बजाय, बकेट यूआरएल होगा. इसलिए, आपको क्रॉस-ऑरिजिन रिसॉर्स शेयरिंग (सीओआरएस) सेटिंग कॉन्फ़िगर करनी होंगी.

cors.json नाम से एक नई फ़ाइल बनाएं और उसमें यह कॉन्टेंट शामिल करें:

touch cors.json
cloudshell edit cors.json

cors.json

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

इस सीओआरएस कॉन्फ़िगरेशन को, हाल ही में बनाई गई स्टोरेज बकेट पर लागू करें:

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

कॉन्फ़िगरेशन को सीक्रेट के तौर पर सेव करना

बैकिंग सेवाएं सेट अप करने के बाद, अब इन वैल्यू को Secret Manager का इस्तेमाल करके सुरक्षित की गई फ़ाइल में सेव किया जा सकेगा.

Secret Manager की मदद से, गोपनीय जानकारी को बाइनरी ब्लॉब या टेक्स्ट स्ट्रिंग के तौर पर सेव, मैनेज, और ऐक्सेस किया जा सकता है. यह कॉन्फ़िगरेशन की जानकारी को स्टोर करने के लिए बेहतर तरीके से काम करता है. जैसे, डेटाबेस पासवर्ड, एपीआई पासकोड या रनटाइम के दौरान किसी ऐप्लिकेशन के लिए ज़रूरी टीएलएस सर्टिफ़िकेट.

सबसे पहले, डेटाबेस कनेक्शन स्ट्रिंग, मीडिया बकेट, 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 को शामिल किया जाएगा. इन वैरिएबल को, सीक्रेट के तौर पर तय की गई वैल्यू से सेट किया जाएगा. इसे लागू करने के लिए, आपको टेंप्लेट सेटिंग का दायरा बढ़ाना होगा. आपको 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 में इस प्रोजेक्ट की ज़रूरी शर्तों का कॉन्टेक्स्ट नहीं होता. इसलिए, हो सकता है कि अमान्य इंपोर्ट और इस्तेमाल न किए गए इंपोर्ट की रिपोर्ट मिले.

Python की डिपेंडेंसी

requirements.txt फ़ाइल ढूंढें और इन पैकेज को जोड़ें:

cloudshell edit requirements.txt

ज़रूरी शर्तें.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 के इन बुनियादी माइग्रेशन कमांड को, आपकी बनाई गई कंटेनर इमेज के हिसाब से चलाना चाहिए. साथ ही, इसे आपके डेटाबेस के ऐक्सेस के साथ चलाया जाना चाहिए.

Django एडमिन में लॉग इन करने के लिए, एडमिन खाता बनाने के लिए आपको createsuperuser चलाना होगा.

ऐसा करने के लिए, आपको इन टास्क को करने के लिए Cloud Run जॉब का इस्तेमाल करना होगा. 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

अब आपके पास तीन एंट्री होनी चाहिए: डिफ़ॉल्ट web एंट्रीपॉइंट, डेटाबेस माइग्रेशन लागू करने के लिए migrate एंट्रीपॉइंट, और createsuperuser कमांड चलाने के लिए createuser एंट्रीपॉइंट.

अपने ऐप्लिकेशन की इमेज बनाना

अपने 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

डिप्लॉयमेंट पूरा होने तक इंतज़ार करें. सफल होने पर, कमांड लाइन सेवा का यूआरएल दिखाती है:

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

अब इस यूआरएल को किसी वेब ब्राउज़र में खोलकर, डिप्लॉय किए गए कंटेनर पर जाएं:

चूंकि यह एक नई स्थापना है, इसलिए आपको स्वचालित रूप से लॉगिन पृष्ठ पर रीडायरेक्ट कर दिया जाएगा.

9. Django एडमिन ऐक्सेस करना

Django CMS की मुख्य सुविधाओं में से एक है इसका इंटरैक्टिव एडमिन.

सीएसआरएफ़ सेटिंग अपडेट करना

Django में किसी दूसरी साइट से किए गए फ़र्ज़ी अनुरोध (सीएसआरएफ़) से सुरक्षा की सुविधाएं शामिल हैं. जब भी आपकी Django साइट पर कोई फ़ॉर्म सबमिट किया जाता है, तो भरोसेमंद ऑरिजिन की सेटिंग की जांच की जाती है. इसमें, Django एडमिन में लॉग इन करना भी शामिल है. अगर यह अनुरोध के मूल से मेल नहीं खाता है, तो Django एक गड़बड़ी देता है.

अगर mysite/settings.py फ़ाइल में, CLOUDRUN_SERVICE_URL एनवायरमेंट वैरिएबल तय किया गया है, तो इसका इस्तेमाल CSRF_TRUSTED_ORIGINS और ALLOWED_HOSTS सेटिंग में किया जाता है. हालांकि, ALLOWED_HOSTS तय करना ज़रूरी नहीं है, लेकिन इसे जोड़ना अच्छा रहता है, क्योंकि CSRF_TRUSTED_ORIGINS के लिए यह पहले से ही ज़रूरी है.

आपको सेवा का यूआरएल चाहिए, इसलिए इस कॉन्फ़िगरेशन को पहले डिप्लॉयमेंट के बाद ही जोड़ा जा सकता है.

इस एनवायरमेंट वैरिएबल को जोड़ने के लिए, आपको अपनी सेवा अपडेट करनी होगी. इसे application_settings सीक्रेट में जोड़ा जा सकता है या सीधे एनवायरमेंट वैरिएबल के तौर पर जोड़ा जा सकता है.

नीचे दिए गए तरीके में, gcloud फ़ॉर्मैटिंग और एस्केपिंग का फ़ायदा लिया गया है.

अपना सेवा यूआरएल वापस पाएं:

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 जोड़ें.

अब उपयोगकर्ता नाम "एडमिन" से लॉग इन करें और निम्न आदेश का उपयोग करके अपना पासवर्ड पुनर्प्राप्त करें:

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

10. ऐप्लिकेशन के अपडेट लागू करना

ऐप्लिकेशन डेवलप करने पर, आपको स्थानीय तौर पर उसकी जांच करनी होगी. इसके लिए, आपको अपने Cloud SQL ("प्रोडक्शन") डेटाबेस या किसी स्थानीय ("टेस्ट") डेटाबेस से कनेक्ट करना होगा.

अपने प्रोडक्शन डेटाबेस से कनेक्ट करना

Cloud SQL Auth प्रॉक्सी का इस्तेमाल करके, अपने Cloud SQL इंस्टेंस से कनेक्ट किया जा सकता है. यह ऐप्लिकेशन, आपकी लोकल मशीन को डेटाबेस से कनेक्ट करता है.

Cloud SQL Auth प्रॉक्सी इंस्टॉल करने के बाद, यह तरीका अपनाएं:

# 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 फ़ाइल हटा दी जाए.

माइग्रेशन बनाना

अपने डेटाबेस मॉडल में बदलाव करते समय, आपको python manage.py makemigrations चलाकर Django की माइग्रेशन फ़ाइलें जनरेट करने की ज़रूरत पड़ सकती है.

प्रोडक्शन या डेटाबेस कनेक्शन की जांच करने के बाद, इस निर्देश को चलाया जा सकता है. इसके अलावा, खाली सेटिंग देकर, डेटाबेस के बिना माइग्रेशन फ़ाइलें जनरेट की जा सकती हैं:

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, मिलने वाले अनुरोधों के हिसाब से आपके कंटेनर की इमेज को अपने-आप और हॉरिज़ॉन्टल तौर पर स्केल करता है. इसके बाद, मांग कम होने पर उसका साइज़ छोटा कर देता है. अनुरोध मैनेज करने के दौरान इस्तेमाल किए गए सीपीयू, मेमोरी, और नेटवर्किंग के लिए ही आपको पैसे चुकाने होंगे.
Cloud SQL की मदद से, मैनेज किए जा रहे PostgreSQL इंस्टेंस का प्रावधान किया जा सकता है. यह इंस्टेंस अपने-आप मैनेज होता है और इसे Google Cloud के कई सिस्टम में नेटिव तौर पर इंटिग्रेट किया जाता है.
Cloud Storage से आपको क्लाउड स्टोरेज मिलता है, जिसे Django में आसानी से ऐक्सेस कर सकता है.
सीक्रेट मैनेजर की मदद से, सीक्रेट स्टोर किए जा सकते हैं. साथ ही, उन्हें Google Cloud के कुछ ही हिस्सों में ऐक्सेस किया जा सकता है, दूसरों से नहीं.

खाली करने के लिए जगह

इस ट्यूटोरियल में इस्तेमाल किए गए संसाधनों के लिए, अपने Google Cloud Platform खाते से शुल्क न लगने के लिए:

Cloud Console में, संसाधन मैनेज करें पेज पर जाएं.
प्रोजेक्ट की सूची में, अपना प्रोजेक्ट चुनें. इसके बाद, मिटाएं पर क्लिक करें.
डायलॉग बॉक्स में, प्रोजेक्ट आईडी टाइप करें. इसके बाद, प्रोजेक्ट मिटाने के लिए शट डाउन करें पर क्लिक करें.

ज़्यादा जानें

Cloud Run पर Django: https://cloud.google.com/python/django/run
Python के साथ Hello Cloud Run: https://codelabs.developers.google.com/codelabs/cloud-run-hello-python3
Google Cloud पर Python: https://cloud.google.com/python
Google Cloud Python क्लाइंट: https://github.com/googleapis/google-cloud-python