Cette page a été traduite par l'API Cloud Translation.
Switch to English

Exécuter Django sur Cloud Run (entièrement géré)

Le déploiement d'applications avec état tel que Django implique l'intégration simultanée de plusieurs services pour former un projet cohérent.

Ce tutoriel part du principe que vous connaissez bien le développement Web Django. L'exemple de code met en œuvre les vues de base, les modèles et les configurations de route. Combiné à l'administrateur interactif Django, cet exemple de code montre comment intégrer les bases de données gérées, le stockage d'objets, les secrets chiffrés et les pipelines de compilation avec le calcul sans serveur.

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 Wailtail et Django CMS.

Schéma illustrant l'architecture du déploiement.
Le site Django est diffusé à partir de Cloud Run, qui utilise plusieurs services externes pour stocker différents types de données (informations de base de données relationnelle, ressources multimédias, secrets de configuration et images de conteneurs). Les services de backend sont mis à jour par Cloud Build lors d'une tâche de compilation et de migration.

Coûts

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 gratuits pour exécuter, tester et déployer des charges de travail.

  2. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder au sélecteur de projet

  3. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  4. Activer les API Cloud Run, Cloud SQL, Cloud Build, Secret Manager, and Compute Engine .

    Activer les API

  5. Installez et initialisez le SDK Cloud.
  6. Assurez-vous que le compte utilisé pour ce tutoriel dispose des autorisations suffisantes.

Cloner l'application Django

Une fois les conditions préalables remplies, téléchargez et déployez l'exemple d'application Django. Les sections suivantes vous guident dans la configuration, l'exécution et le déploiement de cette application.

Cloner l'application Django

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

  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

Préparer les services externes

Ce tutoriel utilise un certain nombre de services Google Cloud pour fournir la base de données, le stockage multimédia et le stockage des secrets compatibles avec le projet Django déployé. Ces services sont déployés dans une région spécifique. Pour assurer l'efficacité des services, il est préférable que tous les services soient déployés dans la même région. Pour en savoir plus sur la région la plus proche de vous, consultez la section Produits disponibles par région.

Configurer une instance Cloud SQL pour PostgreSQL

Django est compatible avec plusieurs bases de données relationnelles, mais offre la plus grande compatibilité avec PostgreSQL, l'un des types de bases de données proposés dans Cloud SQL.

Les sections suivantes décrivent 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 "polls".

Créer une instance PostgreSQL

Console

  1. Dans Cloud Console, 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 PostgreSQL.

  4. Dans le champ ID d'instance, saisissez le nom de l'instance (INSTANCE_NAME).

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

  6. Utilisez les valeurs par défaut dans les autres champs.

  7. Cliquez sur Create (Créer).

gcloud

  1. Créez l'instance PostgreSQL :

    gcloud sql instances create INSTANCE_NAME \
    --project PROJECT_ID \
    --database-version POSTGRES_12 \
    --tier db-f1-micro \
    --region REGION

    Remplacez l'élément suivant :

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

    La création de l'instance prend quelques minutes, et elle est prête à être utilisée.

  2. Définissez un mot de passe pour l'utilisateur postgres.

    gcloud sql users set-password postgres \
    --instance INSTANCE_NAME --prompt-for-password

Créer une base de données

Console

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

    Accéder à la page Instances Cloud SQL

  2. Sélectionnez l'instance INSTANCE_NAME.

  3. Accédez à l'onglet Bases de données.

  4. Cliquez sur Create database.

  5. Dans la boîte de dialogue Nom de la base de données, saisissez DATABASE_NAME.

  6. Cliquez sur Create (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.

Créer un compte utilisateur

Console

  1. Dans Cloud Console, activez Cloud Shell.

    Activer Cloud Shell

  2. Dans Cloud Shell, utilisez le client gcloud 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 maintenant le compte psql. L'invite postgres=> doit s'afficher.

  4. Créez un compte utilisateur :

    CREATE USER 'django' WITH PASSWORD 'PASSWORD';

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

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

    GRANT ALL PRIVILEGES ON DATABASE 'DATABASE_NAME' TO 'django';

  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 maintenant le compte psql. L'invite postgres=> doit s'afficher.

  3. Créez un compte utilisateur :

    CREATE USER 'django' WITH PASSWORD 'PASSWORD';

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

    GRANT ALL PRIVILEGES ON DATABASE 'DATABASE_NAME' TO 'django';

  5. Quittez psql :

    \q

Configurer un bucket Cloud Storage

Cloud Storage permet de stocker des éléments statiques inclus dans Django, ainsi que des supports importés par l'utilisateur, dans un espace de stockage d'objets à haute disponibilité. Le package django-storages[google] gère l'interaction de Django avec ce backend de stockage.

Console

  1. Dans Cloud Console, accédez à la page Navigateur.

    Accéder à la page du navigateur

  2. Cliquez sur Créer un bucket.
  3. Sur la page Créer un bucket, spécifiez les attributs suivants :
  4. Cliquez sur Create (Créer).

gcloud

L'outil de ligne de commande gsutil a été installé lors de l'installation du SDK Cloud.

  • Créez un bucket Cloud Storage :

    gsutil mb -l REGION gs://PROJECT_ID-media

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é.

Cloud Run et Cloud Build interagissent avec les secrets en utilisant leurs comptes de service respectifs, identifiés par une adresse e-mail contenant le numéro du projet.

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 .env sécurisé. L'exemple de code 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 à la fois par Cloud Build et Cloud Run, car ces deux services exécutent Django.

  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 :

    DATABASE_URL=postgres://django:PASSWORD@//cloudsql/PROJECT_ID:REGION:INSTANCE_NAME/DATABASE_NAME
GS_BUCKET_NAME=PROJECT_ID-media
SECRET_KEY=(a random string, length 50)

  2. Stockez le secret dans le gestionnaire de secrets :

Console

  1. Dans Cloud Console, 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 Importer un fichier, sélectionnez le fichier .env stocké localement.

  5. Cliquez sur Créer un secret.

  6. Dans la section Détails pour django_settings, notez le numéro du projet :

    projects/PROJECTNUM/secrets/django_settings

  7. Cliquez sur Ajouter un membre.

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

  9. Dans le champ Nouveaux membres, saisissez PROJECTNUM@cloudbuild.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 un secret, django_settings :

    gcloud secrets create django_settings --replication-policy automatic

  2. Ajoutez le fichier .env en tant que version du secret.

    gcloud secrets versions add django_settings --data-file .env

  3. Pour confirmer la création du secret, vérifiez-le :

    gcloud secrets describe django_settings

    Notez le numéro du projet :

    projects/PROJECTNUM/secrets/django_settings

  4. 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

  5. Accordez l'accès au secret au compte de service Cloud Build :

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

    Dans le résultat, confirmez que bindings (répertorie) les deux comptes de service en tant que membres.

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

L'utilisateur 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 mentionné à partir de Secret Manager.

Console

  1. Dans Cloud Console, 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.

  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 Ajouter un membre.

  8. Dans le champ Nouveaux membres, saisissez PROJECTNUM@cloudbuild.gserviceaccount.com, puis appuyez sur Enter.

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

  10. Cliquez sur Enregistrer.

gcloud

  1. Créez un secret, superuser_password :

    gcloud secrets create superuser_password --replication-policy automatic

  2. Ajoutez un mot de passe généré de manière aléatoire en tant que version de ce secret :

    cat /dev/urandom | tr -dc 'a-zA-Z0-9' | head -c30 > superuser_password

gcloud secrets versions add superuser_password --data-file superuser_password

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

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

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

Autoriser Cloud Build à accéder à Cloud SQL

Pour que Cloud Build puisse appliquer les migrations de base de données, vous devez autoriser Cloud Build à accéder à Cloud SQL.

Console

  1. Dans Cloud Console, accédez à la page Identity and Access Management.

    Accéder à la page "Identity and Access Management"

  2. Pour modifier l'entrée associée à PROJECTNUM@cloudbuild.gserviceaccount.com, cliquez sur Modifier.

  3. Cliquez sur Ajouter un autre rôle.

  4. Dans la boîte de dialogue Sélectionner un rôle, sélectionnez Client Cloud SQL.

  5. Cliquez sur Enregistrer.

gcloud

  1. Autorisez Cloud Build à accéder à Cloud SQL :

    gcloud projects add-iam-policy-binding PROJECT_ID \
    --member serviceAccount:PROJECTNUM@cloudbuild.gserviceaccount.com \
    --role roles/cloudsql.client

Premier déploiement de l'application

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 \
    --platform managed \
    --region REGION \
    --image gcr.io/PROJECT_ID/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 at https://polls-service--uc.a.run.app

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

    Capture d'écran de la page de destination de l'application de sondage.
    Si l'URL du service affiche "You're at the polls index" (Vous êtes sur l'index des sondages), l'application Django a bien été déployée.

  4. 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éfinis précédemment.

    Capture d'écran de l'administrateur Django
    Une fois authentifié, l'administrateur Django s'affiche, indiquant le modèle "Questions" dans l'application "Polls" (Sondages).

Définir des autorisations minimales (facultatif)

Par défaut, ce service est déployé avec le compte de service Compute par défaut. Cependant, dans certains cas, l'utilisation du compte de service par défaut peut fournir trop d'autorisations. Si vous souhaitez être plus restrictif, vous devez créer votre propre compte de service et n'attribuer 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, dans le bucket multimédia
  • Accesseur de secrets, sur le secret des paramètres Django. (Le service lui-même n'a pas besoin d'accéder au code secret de l'administrateur Django.)

Pour créer un compte de service avec les autorisations requises, procédez comme suit:

  1. Dans Cloud Shell, 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 Run Invoker
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member serviceAccount:${SERVICE_ACCOUNT} \
    --role roles/run.Invoker

# 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
gsutil iam ch \
    serviceAccount:${SERVICE_ACCOUNT}:roles/storage.objectAdmin \
    gs://PROJECT_ID-media

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

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

    gcloud run deploy polls-service \
    --platform managed \
    --region REGION \
    --image gcr.io/PROJECT_ID/polls-service \
    --service-account ${SERVICE_ACCOUNT}

Redéployer l'application

Alors que la procédure initiale de création et de déploiement était complexe, le redéploiement est relativement direct.

  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 \
    --platform managed \
    --region REGION \
    --image gcr.io/PROJECT_ID/polls-service

Comprendre le code

L'exemple d'application Django a été créé à l'aide des outils Django standards. Ces commandes 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) :

run/django/mysite/settings.py 
import google.auth
from google.cloud import secretmanager

_, project = google.auth.default()

if project:
    client = secretmanager.SecretManagerServiceClient()

    SETTINGS_NAME = os.environ.get("SETTINGS_NAME", "django_settings")
    name = f"projects/{project}/secrets/{SETTINGS_NAME}/versions/latest"
    payload = client.access_secret_version(name=name).payload.data.decode(
        "UTF-8"
    )
env.read_env(io.StringIO(payload))

Le paramètre django_settings a été utilisé pour stocker plusieurs valeurs secrètes afin de réduire le nombre de secrets différents à configurer.

Bien que superuser_password ait pu être créé directement à partir de la ligne de commande, la méthode basée sur les fichiers a été utilisée à la place. Si le paramètre a été généré depuis la ligne de commande, head -c a permis de déterminer la longueur de la chaîne générée de manière aléatoire, tout en veillant à ce qu'il n'y ait pas de saut de ligne à la fin du fichier, ce qui aurait entraîné des problèmes lors de la saisie du mot de passe dans l'administrateur Django.

Connexion à une base de données

Comme le secret django_settings contenait une chaîne de connexion à la base de données spécialement formée, l'outil d'aide de la base de données django-environ peut être appelé pour attribuer la valeur DATABASES :

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

Cette méthode a été utilisée au lieu de définir des valeurs distinctes pour les composants des informations de connexion à la base de données.

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 :

run/django/mysite/settings.py 
# Define static storage via django-storages[google]
GS_BUCKET_NAME = env("GS_BUCKET_NAME")

DEFAULT_FILE_STORAGE = "storages.backends.gcloud.GoogleCloudStorage"
STATICFILES_STORAGE = "storages.backends.gcloud.GoogleCloudStorage"
GS_DEFAULT_ACL = "publicRead"

Automatisation avec Cloud Build

Le fichier cloudmigrate.yaml exécute non seulement les étapes de compilation d'images classiques (création d'une image de conteneur et transfert de celle-ci vers le registre de conteneurs), mais aussi les commandes Django migrate et collectstatic. Celles-ci nécessitent un accès à la base de données, rendu possible par app-engine-exec-wrapper, un outil d'aide pour le proxy Cloud SQL :

run/django/cloudmigrate.yaml 
steps:
  - id: "build image"
    name: "gcr.io/cloud-builders/docker"
    args: ["build", "-t", "gcr.io/${PROJECT_ID}/${_SERVICE_NAME}", "."]

  - id: "push image"
    name: "gcr.io/cloud-builders/docker"
    args: ["push", "gcr.io/${PROJECT_ID}/${_SERVICE_NAME}"]

  - id: "apply migrations"
    name: "gcr.io/google-appengine/exec-wrapper"
    args:
      [
        "-i",
        "gcr.io/$PROJECT_ID/${_SERVICE_NAME}",
        "-s",
        "${PROJECT_ID}:${_REGION}:${_INSTANCE_NAME}",
        "-e",
        "SETTINGS_NAME=${_SECRET_SETTINGS_NAME}",
        "--",
        "python",
        "manage.py",
        "migrate",
      ]

  - id: "collect static"
    name: "gcr.io/google-appengine/exec-wrapper"
    args:
      [
        "-i",
        "gcr.io/$PROJECT_ID/${_SERVICE_NAME}",
        "-s",
        "${PROJECT_ID}:${_REGION}:${_INSTANCE_NAME}",
        "-e",
        "SETTINGS_NAME=${_SECRET_SETTINGS_NAME}",
        "--",
        "python",
        "manage.py",
        "collectstatic",
        "--verbosity",
        "2",
        "--no-input"
      ]

substitutions:
  _INSTANCE_NAME: django-instance
  _REGION: us-central1
  _SERVICE_NAME: polls-service
  _SECRET_SETTINGS_NAME: django_settings

images:
  - "gcr.io/${PROJECT_ID}/${_SERVICE_NAME}"

Les variables de substitution sont utilisées dans cette configuration. La modification directe des valeurs dans le fichier signifie que l'indicateur --substitutions peut être ignoré au moment de la migration.

Dans cette configuration, seules les migrations existantes sont appliquées. Pour étendre cette configuration afin de générer des migrations, ajoutez une étape makemigrations.

Pour étendre la configuration de Cloud Build afin d'inclure le déploiement dans la configuration unique sans avoir à exécuter deux commandes, consultez la section Déploiement continu à partir de git à l'aide de Cloud Build. Cela nécessite des modifications IAM, comme décrit.

Création de super-utilisateurs avec migrations de données

La commande de gestion Django createsuperuser ne peut être exécutée que de manière interactive, c'est-à-dire lorsque l'utilisateur peut saisir des informations en réponse à des invites. Bien que vous puissiez utiliser cette commande avec le proxy Cloud SQL et exécuter des commandes dans une configuration Docker locale, vous pouvez également créer le super-utilisateur en tant que migration des données:

run/django/mysite/migrations/0001_createsuperuser.py 
import os

from django.contrib.auth.models import User
from django.db import migrations
from django.db.backends.postgresql.schema import DatabaseSchemaEditor
from django.db.migrations.state import StateApps

import google.auth
from google.cloud import secretmanager

def createsuperuser(apps: StateApps, schema_editor: DatabaseSchemaEditor) -> None:
    """
    Dynamically create an admin user as part of a migration
    Password is pulled from Secret Manger (previously created as part of tutorial)
    """
    if os.getenv("TRAMPOLINE_CI", None):
        # We are in CI, so just create a placeholder user for unit testing.
        admin_password = "test"
    else:
        client = secretmanager.SecretManagerServiceClient()

        # Get project value for identifying current context
        _, project = google.auth.default()

        # Retrieve the previously stored admin password
        PASSWORD_NAME = os.environ.get("PASSWORD_NAME", "superuser_password")
        name = f"projects/{project}/secrets/{PASSWORD_NAME}/versions/latest"
        admin_password = client.access_secret_version(name=name).payload.data.decode(
            "UTF-8"
        )

    # Create a new user using acquired password, stripping any accidentally stored newline characters
    User.objects.create_superuser("admin", password=admin_password.strip())

class Migration(migrations.Migration):

    initial = True
    dependencies = []
    operations = [migrations.RunPython(createsuperuser)]

Nettoyage

  1. Dans Cloud Console, 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.