Exécuter Django dans l'environnement Cloud Run

Le déploiement d'applications avec état comme Django sur Cloud Run implique l'intégration de services leur permettant d'interagir entre elles pour former un projet cohérent.

Dans ce tutoriel, nous partons du principe que vous connaissez bien le développement Web avec Django. Si vous débutez dans le développement avec Django, nous vous recommandons d'écrire votre première application Django avant de continuer.

Bien que ce tutoriel illustre spécifiquement Django, vous pouvez utiliser ce processus de déploiement avec d'autres frameworks basés sur Django, tels que Wagtail et le CMS Django.

Ce tutoriel utilise Django 5, qui nécessite au moins Python 3.10.

Objectifs

Au cours de ce tutoriel, vous allez effectuer les opérations suivantes :

  • Créer et connecter une base de données Cloud SQL.
  • Créer et utiliser des valeurs secrètes dans Secret Manager.

  • Déployer une application Django sur Cloud Run.

  • Héberger des fichiers statiques sur Cloud Storage.

  • Utiliser Cloud Build pour automatiser le déploiement.

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

Pour obtenir une estimation des coûts en fonction de votre utilisation prévue, utilisez le simulateur de coût.

Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai sans frais.

Avant de commencer

  1. Connectez-vous à votre compte Google Cloud . Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $de crédits sans frais pour exécuter, tester et déployer des charges de travail.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. Enable the Cloud Run, Cloud SQL, Cloud Build, Secret Manager, Artifact Registry, and Compute Engine APIs.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the APIs

  5. Installez la gcloud CLI.

  6. Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.

  7. Pour initialiser la gcloud CLI, exécutez la commande suivante : 

    gcloud init

  8. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  9. Verify that billing is enabled for your Google Cloud project.

  10. Enable the Cloud Run, Cloud SQL, Cloud Build, Secret Manager, Artifact Registry, and Compute Engine APIs.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the APIs

  11. Installez la gcloud CLI.

  12. Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.

  13. Pour initialiser la gcloud CLI, exécutez la commande suivante : 

    gcloud init
  14. Assurez-vous que le compte utilisé pour ce tutoriel dispose des autorisations suffisantes.

Préparer votre environnement

Cloner une application exemple

Le code de l'exemple d'application Django se trouve dans le dépôt GitHub GoogleCloudPlatform/python-docs-samples.

  1. Vous pouvez soit télécharger l'exemple sous forme de fichier ZIP et l'extraire, soit cloner le dépôt sur votre ordinateur local à l'aide de la commande suivante :

    git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git

  2. Accédez au répertoire qui contient l'exemple de code :

    Linux/macOS

    cd python-docs-samples/run/django

    Windows

    cd python-docs-samples\run\django

Confirmer la configuration de Python

Ce tutoriel s'appuie sur Python pour exécuter l'exemple d'application sur votre machine. L'exemple de code nécessite également l'installation de dépendances.

Pour en savoir plus, consultez le guide de l'environnement de développement Python.

  1. Assurez-vous que la version de Python est au moins la version 3.10.

     python -V

    Vous devriez voir Python 3.10.0 ou une valeur supérieure.

  2. Créez un environnement virtuel Python et installez des dépendances :

    Linux/macOS

    python -m venv venv
source venv/bin/activate
pip install --upgrade pip
pip install -r requirements.txt

    Windows

    python -m venv venv
venv\scripts\activate
pip install --upgrade pip
pip install -r requirements.txt

Téléchargez le proxy d'authentification Cloud SQL pour vous connecter à Cloud SQL depuis votre ordinateur local.

Une fois déployée, votre application communique avec votre instance Cloud SQL via le proxy d'authentification Cloud SQL qui est intégré à l'environnement Cloud Run. Notez toutefois que pour tester votre application en local, vous devez installer et utiliser une copie locale du proxy dans votre environnement de développement. Pour en savoir plus, consultez le guide sur le proxy d'authentification Cloud SQL.

Le proxy d'authentification Cloud SQL utilise l'API Cloud SQL pour interagir avec votre instance SQL. Pour ce faire, il nécessite l'authentification de l'application via la gcloud CLI.

  1. Authentifiez-vous et acquérez des identifiants pour l'API :

    gcloud auth application-default login

  2. Téléchargez et installez le proxy d'authentification Cloud SQL sur votre ordinateur local.

    Linux 64 bits

    1. Téléchargez le proxy d'authentification Cloud SQL : 
      curl -o cloud-sql-proxy https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.21.1/cloud-sql-proxy.linux.amd64
    2. Rendez le proxy d'authentification Cloud SQL exécutable : 
      chmod +x cloud-sql-proxy

    Linux 32 bits

    1. Téléchargez le proxy d'authentification Cloud SQL : 
      curl -o cloud-sql-proxy https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.21.1/cloud-sql-proxy.linux.386
    2. Si la commande curl est introuvable, exécutez sudo apt install curl puis répétez la commande de téléchargement.
    3. Rendez le proxy d'authentification Cloud SQL exécutable : 
      chmod +x cloud-sql-proxy

    macOS 64 bits

    1. Téléchargez le proxy d'authentification Cloud SQL : 
      curl -o cloud-sql-proxy https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.21.1/cloud-sql-proxy.darwin.amd64
    2. Rendez le proxy d'authentification Cloud SQL exécutable : 
      chmod +x cloud-sql-proxy

    Mac M1

    1. Téléchargez le proxy d'authentification Cloud SQL : 
        curl -o cloud-sql-proxy https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.21.1/cloud-sql-proxy.darwin.arm64
    2. Rendez le proxy d'authentification Cloud SQL exécutable : 
        chmod +x cloud-sql-proxy

    Windows 64 bits

    Effectuez un clic droit sur https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.21.1/cloud-sql-proxy.x64.exe et sélectionnez Enregistrer le lien sous pour télécharger le proxy d'authentification Cloud SQL. Renommez le fichier en cloud-sql-proxy.exe.

    Windows 32 bits

    Effectuez un clic droit sur https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.21.1/cloud-sql-proxy.x86.exe et sélectionnez Enregistrer le lien sous pour télécharger le proxy d'authentification Cloud SQL. Renommez le fichier en cloud-sql-proxy.exe.

    Image Docker du proxy d'authentification Cloud SQL

    Le proxy d'authentification Cloud SQL possède différentes images de conteneur, telles que distroless, alpine et buster. L'image de conteneur du proxy d'authentification Cloud SQL par défaut utilise distroless, qui ne contient aucune interface système. Si vous avez besoin d'une interface système ou d'outils associés, téléchargez une image basée sur alpine ou buster. Pour plus d'informations, consultez la page Images de conteneurs du proxy d'authentification Cloud SQL.

    Vous pouvez extraire la dernière image sur votre ordinateur local en utilisant Docker avec la commande suivante :

    docker pull gcr.io/cloud-sql-connectors/cloud-sql-proxy:2.21.1

    Autres systèmes d'exploitation

    Pour les autres systèmes d'exploitation non inclus ici, vous pouvez compiler le proxy d'authentification Cloud SQL à partir de la source.

    Vous pouvez déplacer le téléchargement vers un emplacement courant, tel qu'un emplacement sur votre PATH ou dans votre répertoire d'accueil. Si vous choisissez cette solution, lorsque vous démarrerez le proxy d'authentification Cloud SQL plus tard dans le tutoriel, n'oubliez pas de faire référence à l'emplacement que vous avez choisi lors de l'utilisation des commandes cloud-sql-proxy.

Créer des services externes

Dans ce tutoriel, nous utilisons plusieurs services Google Cloud pour fournir la base de données, le stockage multimédia et le stockage de secrets compatibles avec le projet Django déployé. Ces services sont déployés dans une région spécifique. Pour plus d'efficacité entre les services, tous les services doivent être déployés dans la même région. Pour en savoir plus sur la région la plus proche de vous, consultez Produits disponibles par région.

Ce tutoriel utilise les mécanismes d'hébergement d'éléments statiques intégrés dans Cloud Run.

Configurer une instance Cloud SQL pour PostgreSQL

Django est officiellement compatible avec plusieurs bases de données relationnelles, mais offre la plus grande compatibilité avec PostgreSQL. PostgreSQL est compatible avec Cloud SQL. Ce tutoriel choisit donc d'utiliser ce type de base de données.

La section suivante décrit la création d'une instance PostgreSQL, d'une base de données et d'un utilisateur de base de données pour l'application.

  1. Créez l'instance PostgreSQL :

    Console

    1. Dans la console Google Cloud , accédez à la page Instances Cloud SQL.

      Accéder à la page Instances Cloud SQL

    2. Cliquez sur Create Instance (Créer une instance).

    3. Cliquez sur Choisir PostgreSQL.

    4. Pour Édition SQL, sélectionnez "Enterprise".

    5. Pour Préréglage de l'édition, sélectionnez "Bac à sable".

    6. Dans le champ ID d'instance, saisissez INSTANCE_NAME.

    7. Indiquez le mot de passe de l'utilisateur postgres.

    8. Conservez les valeurs par défaut des autres champs.

    9. Cliquez sur Créer une instance.

    La préparation de l'instance peut prendre quelques minutes.

    gcloud

    • Créez l'instance PostgreSQL :

      gcloud sql instances create INSTANCE_NAME \
    --project PROJECT_ID \
    --database-version POSTGRES_16 \
    --tier db-n1-standard-2 \
    --region REGION

    Remplacez l'élément suivant :

    • INSTANCE_NAME : nom de l'instance Cloud SQL
    • PROJECT_ID : ID du projet Google Cloud
    • REGION : Google Cloud région

    La création de l'instance et la préparation à son utilisation prennent quelques minutes.

  2. Dans l'instance créée, créez une base de données :

    Console

    1. Sur la page de votre instance, accédez à l'onglet Bases de données.
    2. Cliquez sur Créer une base de données.
    3. Dans la boîte de dialogue Nom de la base de données, saisissez DATABASE_NAME.
    4. Cliquez sur Créer.

    gcloud

    • Créez la base de données dans l'instance récemment créée :

      gcloud sql databases create DATABASE_NAME \
    --instance INSTANCE_NAME

      Remplacez DATABASE_NAME par le nom de la base de données dans l'instance.

  3. Créez un utilisateur de base de données :

    Console

    1. Dans la page de votre instance, accédez à l'onglet Utilisateurs.
    2. Cliquez sur Ajouter un compte utilisateur.
    3. Dans la boîte de dialogue Choisir le mode d'authentification, sous "Authentification intégrée" :
    4. Saisissez le nom d'utilisateur DATABASE_USERNAME.
    5. Saisissez le mot de passe DATABASE_PASSWORD.
    6. Cliquez sur Ajouter.

    gcloud

    • Créez l'utilisateur dans l'instance récemment créée :

      gcloud sql users create DATABASE_USERNAME \
    --instance INSTANCE_NAME \
    --password DATABASE_PASSWORD

      Remplacez PASSWORD par un mot de passe sécurisé.

Configurer Artifact Registry

Utilisez Artifact Registry pour créer un registre permettant de stocker votre image de conteneur.

Console

  1. Dans la console Google Cloud , accédez à la page Artifact Registry.

    Accéder à la page Artifact Registry

  2. Cliquez sur Créer un dépôt.

  3. Saisissez ce qui suit :

    • Dans le champ Nom, saisissez "cloud-run-source-deploy".
    • Pour Format, sélectionnez "Docker".
    • Pour Région, sélectionnez REGION.

  4. Conservez les valeurs par défaut des autres champs.

  5. Cliquez sur Créer.

gcloud

  • Créez un dépôt Artifact Registry :
gcloud artifacts repositories create cloud-run-source-deploy \
    --repository-format docker \
    --location REGION

Configurer un bucket Cloud Storage

Vous pouvez stocker les éléments statiques inclus dans Django, ainsi que les contenus multimédias importés par les utilisateurs, dans un espace de stockage des objets à disponibilité élevée à l'aide de Cloud Storage. Le package django-storages[google] gère les interactions de Django avec ce backend de stockage.

Console

  1. Dans la console Google Cloud , accédez à la page Cloud Storage.

    Accéder à la page Cloud Storage

  2. Cliquez sur Créer un bucket.

  3. Saisissez les informations suivantes (en cliquant sur "Continuer" si nécessaire) :

    • Dans le champ Nom, saisissez "PROJECT_ID_MEDIA_BUCKET".
    • Pour Région, sélectionnez REGION.
    • Pour Classe de stockage, conservez les valeurs par défaut.
    • Pour Empêcher l'accès public, décochez "Appliquer la protection contre l'accès public".
    • Dans Contrôle des accès, sélectionnez "Ultraprécis".

  4. Conservez les valeurs par défaut des autres champs.

  5. Cliquez sur Créer.

gcloud

  • Créez un bucket Cloud Storage :

    gcloud storage buckets create gs://PROJECT_ID_MEDIA_BUCKET --location=REGION

    Remplacez MEDIA_BUCKET par un suffixe pour le bucket multimédia. Combiné à l'ID du projet, il crée un nom de bucket unique.

Stocker les valeurs du secret dans Secret Manager

Maintenant que les services externes sont configurés, Django a besoin d'informations sur ces services. Au lieu de placer ces valeurs directement dans le code source de Django, ce tutoriel utilise Secret Manager pour stocker ces informations en toute sécurité.

Créer un fichier d'environnement Django en tant que secret Secret Manager

Vous stockez les paramètres requis pour démarrer Django dans un fichier d'environnement sécurisé. L'exemple d'application utilise l'API Secret Manager pour récupérer la valeur du secret, et le package django-environ pour charger les valeurs dans l'environnement Django. Le secret est configuré pour être accessible par Cloud Run et Cloud Build.

  1. Créez un fichier appelé .env, en définissant la chaîne de connexion à la base de données, le nom du bucket multimédia et une nouvelle valeur SECRET_KEY :

    echo DATABASE_URL=postgres://DATABASE_USERNAME:DATABASE_PASSWORD@//cloudsql/PROJECT_ID:REGION:INSTANCE_NAME/DATABASE_NAME > .env
echo GS_BUCKET_NAME=PROJECT_ID_MEDIA_BUCKET >> .env
echo SECRET_KEY=$(cat /dev/urandom | LC_ALL=C tr -dc '[:alpha:]'| fold -w 50 | head -n1) >> .env

  2. Stockez le secret dans le gestionnaire de secrets :

    Console

    1. Dans la console Google Cloud , accédez à la page Secret Manager.

      Accéder à la page Secret Manager

    2. Cliquez sur Créer un secret.

    3. Dans le champ Nom, saisissez django_settings.

    4. Dans la boîte de dialogue Valeur du secret, collez le contenu de votre fichier .env.

    5. Cliquez sur Créer un secret.

    6. Supprimez le fichier local pour empêcher tout remplacement des paramètres locaux.

    gcloud

    1. Créez le secret django_settings avec la valeur du fichier .env :

      gcloud secrets create django_settings --data-file .env

    2. Supprimez le fichier local pour empêcher tout remplacement des paramètres locaux :

      rm .env

  3. Configurez l'accès au secret :

    Console

    1. Dans Secret : django_settings, notez le numéro du projet :

      projects/PROJECTNUM/secrets/django_settings

    2. Cliquez sur l'onglet Autorisations.

    3. Cliquez sur Accorder l'accès.

    4. Dans le champ Nouveaux membres, saisissez PROJECTNUM-compute@developer.gserviceaccount.com, puis appuyez sur Enter.

    5. Dans le menu déroulant Rôle, sélectionnez Accesseur de secrets de Secret Manager.

    6. Cliquez sur Enregistrer.

    gcloud

    1. Obtenez la valeur du numéro de projet (PROJECTNUM) :

      gcloud projects describe PROJECT_ID --format='value(projectNumber)'

    1. Accordez l'accès au secret au compte de service Cloud Run :

      gcloud secrets add-iam-policy-binding django_settings \
    --member serviceAccount:PROJECTNUM-compute@developer.gserviceaccount.com \
    --role roles/secretmanager.secretAccessor

    Dans le résultat, confirmez que bindings identifie le nouveau compte de service.

Créer un secret pour le mot de passe administrateur de Django

L'administrateur Django est normalement créé en exécutant la commande de gestion interactive createsuperuser.

Ce tutoriel utilise une migration de données pour créer l'administrateur, en récupérant le mot de passe administrateur à partir de Secret Manager.

Console

  1. Dans la console Google Cloud , accédez à la page Secret Manager.

  2. Cliquez sur Créer un secret.

  3. Dans le champ Nom, saisissez superuser_password.

  4. Dans le champ Valeur du secret, saisissez un mot de passe aléatoire et unique.

  5. Cliquez sur Créer un secret.

  6. Dans la section Détails pour superuser_password, notez le numéro du projet (projects/PROJECTNUM/secrets/superuser_password).

  7. Cliquez sur l'onglet Autorisations.

  8. Cliquez sur Ajouter.

  9. Dans le champ Nouveaux membres, saisissez PROJECTNUM-compute@developer.gserviceaccount.com, puis appuyez sur Enter.

  10. Dans le menu déroulant Rôle, sélectionnez Accesseur de secrets de Secret Manager.

  11. Cliquez sur Enregistrer.

gcloud

  1. Créez le secret superuser_password à partir d'un mot de passe généré de manière aléatoire :

    echo -n "$(cat /dev/urandom | LC_ALL=C tr -dc '[:alpha:]'| fold -w 30 | head -n1)" | gcloud secrets create superuser_password --data-file -

  2. Accordez l'accès au secret à Cloud Build :

    gcloud secrets add-iam-policy-binding superuser_password \
    --member serviceAccount:PROJECTNUM-compute@developer.gserviceaccount.com \
    --role roles/secretmanager.secretAccessor

    Dans le résultat, confirmez que bindings ne répertorie que Cloud Build en tant que membre.

Exécuter l'application sur votre ordinateur local

Maintenant que les services externes sont configurés, vous pouvez exécuter l'application sur votre ordinateur. Cette configuration permet le développement local et l'application de migrations de bases de données. Notez que les migrations de bases de données sont également appliquées dans Cloud Build, mais vous devez disposer de cette configuration locale pour pouvoir utiliser makemigrations.

  1. Dans un terminal distinct, démarrez le proxy d'authentification Cloud SQL :

    Linux/macOS

    ./cloud-sql-proxy PROJECT_ID:REGION:INSTANCE_NAME

    Windows

    cloud-sql-proxy.exe PROJECT_ID:REGION:INSTANCE_NAME

    Cette étape permet d'établir une connexion depuis votre ordinateur local vers votre instance Cloud SQL à des fins de test. N'arrêtez pas le proxy d'authentification Cloud SQL lors du test local de votre application. L'exécution de ce processus dans un terminal distinct vous permet de continuer à travailler pendant son exécution.

  2. Dans le terminal d'origine, définissez l'ID de projet localement (utilisé par l'API Secret Manager) :

    Linux/macOS

    export GOOGLE_CLOUD_PROJECT=PROJECT_ID

    Windows

    set GOOGLE_CLOUD_PROJECT=PROJECT_ID

  3. Définissez une variable d'environnement pour indiquer que vous utilisez le proxy d'authentification Cloud SQL (cette valeur est reconnue dans le code) :

    Linux/macOS

    export USE_CLOUD_SQL_AUTH_PROXY=true

    Windows

    set USE_CLOUD_SQL_AUTH_PROXY=true

  4. Exécutez les migrations Django pour configurer vos modèles et vos éléments :

    python manage.py makemigrations
python manage.py makemigrations polls
python manage.py migrate
python manage.py collectstatic

  5. Démarrez le serveur Web Django :

    python manage.py runserver 8080

  6. Dans votre navigateur, accédez à http://localhost:8080.

    Si vous êtes dans Cloud Shell, cliquez sur le bouton Aperçu sur le Web, puis sélectionnez Prévisualiser sur le port 8080.

    La page affiche le texte suivant : "Hello, world. You're at the polls index." Le serveur Web Django qui s'exécute sur votre ordinateur diffuse les pages de l'exemple d'application.

  7. Appuyez sur Ctrl/Cmd+C pour arrêter le serveur Web local.

Déployer l'application sur Cloud Run

Avec la configuration des services externes, vous pouvez maintenant déployer le service Cloud Run.

  1. À l'aide du fichier cloudmigrate.yaml fourni, utilisez Cloud Build pour créer l'image, exécuter les migrations de la base de données et renseigner les éléments statiques :

    gcloud builds submit --config cloudmigrate.yaml \
    --substitutions _INSTANCE_NAME=INSTANCE_NAME,_REGION=REGION

    Cette première compilation prend quelques minutes.

  2. Une fois la compilation réussie, déployez le service Cloud Run pour la première fois en définissant la région du service, l'image de base et l'instance Cloud SQL connectée :

    gcloud run deploy polls-service \
    --region REGION \
    --image REGION-docker.pkg.dev/PROJECT_ID/cloud-run-source-deploy/polls-service \
    --add-cloudsql-instances PROJECT_ID:REGION:INSTANCE_NAME \
    --allow-unauthenticated

    Vous devriez obtenir un résultat indiquant que le déploiement a réussi, avec une URL de service :

    Service [polls-service] revision [polls-service-00001-tug] has been deployed
and is serving 100 percent of traffic.
Service URL: https://polls-service-PROJECT_ID.REGION.run.app

  3. Mettez à jour le service en utilisant les URL de service comme variable d'environnement.

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

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

  4. Pour afficher le service déployé, accédez à l'URL du service.

  5. Pour vous connecter à l'administrateur Django, ajoutez /admin à l'URL et connectez-vous avec le nom d'utilisateur admin et le mot de passe défini précédemment.

    Pour récupérer le mot de passe du super-utilisateur depuis Secret Manager :

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

Mettre à jour l'application

Alors que la procédure initiale de création et de déploiement était complexe, la mise à jour est un processus plus simple :

  1. Exécutez le script de compilation et de migration Cloud Build :

    gcloud builds submit --config cloudmigrate.yaml \
    --substitutions _INSTANCE_NAME=INSTANCE_NAME,_REGION=REGION

  2. Déployez le service en spécifiant uniquement la région et l'image :

    gcloud run deploy polls-service \
    --region REGION \
    --image REGION-docker.pkg.dev/PROJECT_ID/cloud-run-source-deploy/polls-service

Configurer pour la production

Votre déploiement Django est opérationnel, mais vous pouvez suivre d'autres étapes pour vous assurer que votre application est prête pour la production.

Désactiver le débogage

Vérifiez que la variable DEBUG dans mysite/settings.py est définie sur False. Cela empêche l'affichage pour l'utilisateur de pages d'erreur détaillées, ce qui peut conduire à des fuites des informations sur les configurations.

Limiter les droits d'utilisateur de la base de données

Tous les utilisateurs créés à l'aide de Cloud SQL disposent des droits associés au rôle cloudsqlsuperuser : CREATEROLE, CREATEDB et LOGIN.

Pour empêcher l'utilisateur de la base de données Django de disposer de ces autorisations, créez-le manuellement dans PostgreSQL. Vous devrez avoir installé le terminal interactif psql ou utiliser Cloud Shell, dans lequel cet outil est préinstallé.

Console

  1. Dans la console Google Cloud , activez Cloud Shell.

    Activer Cloud Shell

  2. Dans Cloud Shell, utilisez le terminal intégré pour vous connecter à votre instance INSTANCE_NAME :

    gcloud sql connect INSTANCE_NAME --user postgres

  3. Saisissez le mot de passe utilisateur Postgres.

    Vous utilisez désormais psql. L'invite postgres=> doit s'afficher.

  4. Créez un compte utilisateur :

    CREATE USER DATABASE_USERNAME WITH PASSWORD 'DATABASE_PASSWORD';

    Remplacez PASSWORD par un mot de passe unique et aléatoire.

  5. Accordez tous les droits sur la nouvelle base de données au nouvel utilisateur :

    GRANT ALL PRIVILEGES ON DATABASE DATABASE_NAME TO DATABASE_USERNAME;

  6. Quittez psql :

    \q

gcloud

  1. Démarrez une connexion à l'instance SQL :

    gcloud sql connect INSTANCE_NAME --user postgres

    Remplacez INSTANCE_NAME par l'instance Cloud SQL créée.

  2. Saisissez le mot de passe utilisateur Postgres.

    Vous utilisez désormais psql. L'invite postgres=> doit s'afficher.

  3. Créez un compte utilisateur :

    CREATE USER DATABASE_USERNAME WITH PASSWORD 'DATABASE_PASSWORD';

  4. Accordez tous les droits sur la nouvelle base de données au nouvel utilisateur :

    GRANT ALL PRIVILEGES ON DATABASE DATABASE_NAME TO DATABASE_USERNAME;

  5. Quittez psql :

    \q

Définir des autorisations minimales

Par défaut, ce service est déployé avec le compte de service de calcul par défaut. Toutefois, dans certains cas, l'utilisation du compte de service par défaut peut fournir un trop grand nombre d'autorisations. Si vous souhaitez être plus restrictif, vous devez créer votre propre compte de service et ne lui accorder que les autorisations requises par votre service. Les autorisations requises peuvent varier d'un service à l'autre, en fonction des ressources utilisées par un service particulier.

Les rôles de projet minimaux requis par ce service sont les suivants :

  • Demandeur Cloud Run
  • Client Cloud SQL
  • Administrateur de l'espace de stockage sur le bucket multimédia
  • Accesseur Secret Manager sur le secret des paramètres Django (l'accès au secret d'administrateur Django n'est pas requis par le service lui-même)

Pour créer un compte de service disposant des autorisations requises, puis l'attribuer au service, exécutez la commande suivante :

  1. Dans la gcloud CLI, créez un compte de service avec les rôles requis :

    gcloud iam service-accounts create polls-service-account
SERVICE_ACCOUNT=polls-service-account@PROJECT_ID.iam.gserviceaccount.com

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

# Storage Admin, on the media bucket
gcloud storage buckets add-iam-policy-binding gs://MEDIA_BUCKET \
    --member=serviceAccount:${SERVICE_ACCOUNT} \
    --role=roles/storage.objectAdmin

# Secret Accessor, on the Django settings secret.
gcloud secrets add-iam-policy-binding django_settings \
    --member serviceAccount:${SERVICE_ACCOUNT} \
    --role roles/secretmanager.secretAccessor

# Secret Accessor, on the Django super user password.
gcloud secrets add-iam-policy-binding superuser_password \
    --member serviceAccount:${SERVICE_ACCOUNT} \
    --role roles/secretmanager.secretAccessor

  2. Déployez le service, en l'associant au nouveau compte de service :

    gcloud run services update polls-service \
    --region REGION \
    --service-account ${SERVICE_ACCOUNT}

  3. Mettez à jour les jobs Cloud Run dans cloudmigrate.yaml pour qu'ils disposent également de ce paramètre --service-account.

Comprendre le code

Exemple d'application

L'exemple d'application Django a été créé à l'aide des outils Django standards. Les commandes suivantes créent le projet et l'application polls :

django-admin startproject mysite
python manage.py startapp polls

Les vues de base, les modèles et les configurations de routage ont été copiés à partir du tutoriel Écrire votre première application Django (Partie 1 et Partie 2).

Secrets de Secret Manager

Le fichier settings.py contient du code qui utilise l'API Python Secret Manager pour récupérer la dernière version du secret nommé et l'extraire dans l'environnement (à l'aide de django-environ) :

# SECURITY WARNING: don't run with debug turned on in production!
# Change this to "False" when you are ready for production
env = environ.Env(DEBUG=(bool, True))
env_file = os.path.join(BASE_DIR, ".env")

# Attempt to load the Project ID into the environment, safely failing on error.
try:
    _, os.environ["GOOGLE_CLOUD_PROJECT"] = google.auth.default()
except google.auth.exceptions.DefaultCredentialsError:
    pass

if os.path.isfile(env_file):
    # Use a local secret file, if provided

    env.read_env(env_file)
# ...
elif os.environ.get("GOOGLE_CLOUD_PROJECT", None):
    # Pull secrets from Secret Manager
    project_id = os.environ.get("GOOGLE_CLOUD_PROJECT")

    client = secretmanager.SecretManagerServiceClient()
    settings_name = os.environ.get("SETTINGS_NAME", "django_settings")
    name = f"projects/{project_id}/secrets/{settings_name}/versions/latest"
    payload = client.access_secret_version(name=name).payload.data.decode("UTF-8")

    env.read_env(io.StringIO(payload))
else:
    raise Exception("No local .env or GOOGLE_CLOUD_PROJECT detected. No secrets found.")

Le secret est utilisé pour stocker plusieurs valeurs secrètes afin de réduire le nombre de secrets différents à configurer.

Configurations CSRF

Django offre une protection intégrée contre la falsification de requête intersite (CSRF). À partir de Django 4.0, des modifications apportées à son fonctionnement impliquent qu'il est important d'indiquer à Django l'URL de son hôte afin qu'il puisse offrir la meilleure protection aux utilisateurs qui envoient des données.

Vous fournissez l'URL de l'application en tant que variable d'environnement dans le fichier settings.py. Il s'agit de la valeur que Django utilise pour les paramètres concernés.

# SECURITY WARNING: It's recommended that you use this when
# running in production. The URLs will be known once you first deploy
# to Cloud Run. This code takes the URLs and converts it to both these settings formats.
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]

    SECURE_SSL_REDIRECT = True
    SECURE_PROXY_SSL_HEADER = ("HTTP_X_FORWARDED_PROTO", "https")
else:
    ALLOWED_HOSTS = ["*"]

Remplacement des secrets locaux

Si un fichier .env se trouve sur le système de fichiers local, il est utilisé à la place de la valeur de Secret Manager. La création d'un fichier .env localement peut être utile pour les tests locaux (par exemple, développement local avec une base de données SQLite ou d'autres paramètres locaux).

Connexion à une base de données

Le fichier settings.py contient la configuration de la base de données SQL. Il utilise l'assistant env.db() de django-environ pour charger la chaîne de connexion définie dans DATABASE_URL dans le paramètre DATABASES.

Lorsque vous exécutez l'application en local et que vous utilisez le proxy d'authentification Cloud SQL pour accéder à la base de données hébergée, l'indicateur USE_CLOUD_SQL_AUTH_PROXY ajuste les paramètres de la base de données pour utiliser le proxy.

# Use django-environ to parse the connection string
DATABASES = {"default": env.db()}

# If the flag as been set, configure to use proxy
if os.getenv("USE_CLOUD_SQL_AUTH_PROXY", None):
    DATABASES["default"]["HOST"] = "127.0.0.1"
    DATABASES["default"]["PORT"] = 5432

Contenu statique stocké dans le cloud

Le fichier settings.py utilise également django-storages pour intégrer le bucket multimédia Cloud Storage directement au projet :

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

Automatisation avec Cloud Build

Le cloudmigrate.yaml gère toutes les étapes nécessaires pour créer une image de conteneur et l'utiliser pour appliquer des migrations de base de données.

Ce tutoriel choisit d'utiliser des buildpacks pour créer l'image de conteneur et des points d'entrée personnalisés dans Procfile pour gérer les commandes de gestion. Les jobs Cloud Run peuvent ensuite y faire référence pour exécuter les commandes.

steps:
  - id: "Build Container Image"
    name: gcr.io/k8s-skaffold/pack
    args: ["build", "${_IMAGE_NAME}", "--builder=gcr.io/buildpacks/builder"]

  - id: "Push Container Image"
    name: "gcr.io/cloud-builders/docker"
    args: ["push", "${_IMAGE_NAME}"]

  - id: "Migrate database"
    name: "gcr.io/google.com/cloudsdktool/cloud-sdk"
    entrypoint: /bin/bash
    args:
      - "-c"
      - |
        gcloud run jobs create migrate-job \
          --region ${_REGION} \
          --image ${_IMAGE_NAME} \
          --set-cloudsql-instances ${_CLOUD_SQL_CONNECTION_NAME} \
          --set-env-vars SETTINGS_NAME=${_SECRET_SETTINGS_NAME} \
          --command migrate \
          --execute-now

  - id: "Create superuser"
    name: "gcr.io/google.com/cloudsdktool/cloud-sdk"
    entrypoint: /bin/bash
    args:
      - "-c"
      - |
        gcloud run jobs create superuser-job \
          --region ${_REGION} \
          --image ${_IMAGE_NAME} \
          --set-cloudsql-instances ${_CLOUD_SQL_CONNECTION_NAME} \
          --set-env-vars SETTINGS_NAME=${_SECRET_SETTINGS_NAME} \
          --set-env-vars DJANGO_SUPERUSER_EMAIL=${_ADMIN_EMAIL} \
          --set-secrets DJANGO_SUPERUSER_PASSWORD=${_ADMIN_PASSWORD_NAME}:latest \
          --command createsuperuser \
          --execute-now

options:
  dynamicSubstitutions: true

substitutions:
  _INSTANCE_NAME: django-instance
  _CLOUD_SQL_CONNECTION_NAME: ${PROJECT_ID}:${_REGION}:${_INSTANCE_NAME}
  _REGION: us-central1
  _SERVICE_NAME: polls-service
  _SECRET_SETTINGS_NAME: django_settings
  _ARTIFACT_REGISTRY: cloud-run-source-deploy
  _IMAGE_NAME: ${_REGION}-docker.pkg.dev/${PROJECT_ID}/${_ARTIFACT_REGISTRY}/${_SERVICE_NAME}
  _ADMIN_EMAIL: example@example.com
  _ADMIN_PASSWORD_NAME: superuser_password

images:
  - "${_IMAGE_NAME}"

Des variables de substitution sont utilisées dans cette configuration.

Création de super-utilisateurs avec des jobs Cloud Run

La commande de gestion Django createsuperuser peut être exécutée de manière non interactive en définissant DJANGO_SUPERUSER_EMAIL et DJANGO_SUPERUSER_PASSWORD.

Ce tutoriel choisit d'utiliser Cloud Run Jobs pour exécuter cette commande. Pour ce faire, ajoutez une entrée personnalisée dans Procfile, qui exécute createsuperuser.

# Create superuser (requires DJANGO_SUPERUSER_PASSWORD and DJANGO_SUPERUSER_EMAIL envvars)
createsuperuser: python manage.py createsuperuser --username admin --noinput || echo "User already exists."

Effectuer un nettoyage

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Supprimer le projet

  1. Dans la console Google Cloud , accédez à la page Gérer les ressources.

    Accéder à la page "Gérer les ressources"

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Étapes suivantes