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 comme Django implique l'intégration de plusieurs services pour interagir ensemble pour former un projet cohérent.

Dans ce tutoriel, nous partons du principe que vous maîtrisez le développement Web Django. L'exemple de code met en œuvre les vues de base, les modèles et les configurations de routage. Combiné à l'administrateur Django interactif, cet exemple de code montre comment intégrer des bases de données gérées, un stockage d'objets, des codes secrets chiffrés et créer des pipelines avec le calcul sans serveur.

Bien que ce tutoriel présente Django spécifiquement, vous pouvez utiliser ce processus de déploiement avec d'autres frameworks basés sur Django, tels que Wagtail 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.

    Si vous n'en possédez pas déjà un, vous devez en créer un.

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

    Accéder à la page de sélection du 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 différents services Google Cloud pour fournir la base de données, le stockage multimédia et le stockage secret compatibles avec le projet Django déployé. Ces services sont déployés dans une région spécifique. Pour une efficacité entre les services, il est préférable que tous les services soient déployés dans la même région. Pour plus d'informations sur la région la plus proche de vous, consultez la page 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 un nom pour 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 peut être prête à l'emploi.

  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 de 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 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 suffisamment secret.

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

Vous pouvez stocker les éléments statiques inclus Django, ainsi que les fichiers importés par l'utilisateur, dans un espace de stockage d'objets hautement disponible à l'aide de Cloud Storage. 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 Cloud Storage.

    Accéder au navigateur Cloud Storage

  2. Cliquez sur Créer un bucket.
  3. Dans la boîte de dialogue 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_BUCKET
    

    Remplacez MEDIA_BUCKET par un suffixe pour le bucket multimédia. Combiné à l'ID du projet, cela 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é.

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 devez stocker 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_BUCKET
    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 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 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 concernant 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 \
        --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, puis connectez-vous avec le nom d'utilisateur admin et le mot de passe défini 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. Toutefois, dans certains cas, le 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 à un autre selon les 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 Storage, sur le bucket multimédia
  • Accesseur de secrets, sur le secret des paramètres Django. (L'accès au code secret de l'administrateur Django n'est pas requis par le service lui-même.)

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://MEDIA_BUCKET
    
    # 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 \
        --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
    

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) :

        import google.auth
        from google.cloud import secretmanager_v1

        _, project = google.auth.default()

        if project:
            client = secretmanager_v1.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"
            )

    with open(env_file, "w") as f:
        f.write(payload)

env = environ.Env()
env.read_env(env_file)

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 :

# Use django-environ to define 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 :

# 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 :

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",
        "--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. Si vous modifiez directement les valeurs du fichier, l'option --substitutions peut être ignorée lors 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 Cloud Build afin d'inclure le déploiement dans une 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éer un super-utilisateur avec des migrations de données

La commande de gestion Django createsuperuser ne peut être exécutée de manière interactive que 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 de données:

import os

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_v1

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):
        admin_password = "test"
    else:
        client = secretmanager_v1.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
    from django.contrib.auth.models import User

    User.objects.create_superuser("admin", password=admin_password)

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.