Exécuter Django sur Google Kubernetes Engine

Les applications Django qui s'exécutent sur GKE évoluent de manière dynamique en fonction du trafic.

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.

Vous devez également avoir installé Docker.

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 Kubernetes.
Déployer une application Django sur Google Kubernetes Engine.

Coûts

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

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Avant de commencer

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.

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Cloud SQL, GKE and Compute Engine APIs.

Enable the APIs

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Cloud SQL, GKE and Compute Engine APIs.

Enable the APIs

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

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.

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

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

Linux/macOS

cd python-docs-samples/kubernetes_engine/django_tutorial

Windows

cd python-docs-samples\kubernetes_engine\django_tutorial

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.

Assurez-vous que la version de Python est au moins la version 3.7.
```
 python -V
```
Vous devriez voir Python 3.7.3 ou une valeur supérieure.

Remarque : Si un numéro de version commence par "2", vous devrez peut-être exécuter python3 au lieu de python. Si tel est le cas, n'oubliez pas de faire référence à l'installation Python de votre choix lorsque vous exécutez des commandes python.

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 env
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 Google Kubernetes Engine. 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 plus de détails, reportez-vous au guide sur les proxys 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 gcloud.

Authentifiez-vous et acquérez des identifiants pour l'API :
```
gcloud auth application-default login
```
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 :
  wget https://dl.google.com/cloudsql/cloud_sql_proxy.linux.amd64 -O cloud_sql_proxy
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 :
  wget https://dl.google.com/cloudsql/cloud_sql_proxy.linux.386 -O cloud_sql_proxy
2. Si la commande wget est introuvable, exécutez sudo apt-get install wget 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://dl.google.com/cloudsql/cloud_sql_proxy.darwin.amd64
2. Rendez le proxy d'authentification Cloud SQL exécutable :
  chmod +x cloud_sql_proxy
macOS 32 bits
1. Téléchargez le proxy d'authentification Cloud SQL :
  curl -o cloud_sql_proxy https://dl.google.com/cloudsql/cloud_sql_proxy.darwin.386
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://dl.google.com/cloudsql/cloud_sql_proxy.darwin.arm64
2. Rendez le proxy d'authentification Cloud SQL exécutable :
  chmod +x cloud_sql_proxy
Windows 64 bits
Pour télécharger le proxy d'authentification Cloud SQL, effectuez un clic droit sur le lien https://dl.google.com/cloudsql/cloud_sql_proxy_x64.exe, puis sélectionnez Enregistrer le lien sous. Renommez le fichier en cloud_sql_proxy.exe.

Windows 32 bits
Pour télécharger le proxy d'authentification Cloud SQL, effectuez un clic droit sur le lien https://dl.google.com/cloudsql/cloud_sql_proxy_x86.exe, puis sélectionnez Enregistrer le lien sous. Renommez le fichier en cloud_sql_proxy.exe.
Image Docker du proxy d'authentification Cloud SQL
Pour plus de commodité, plusieurs images de conteneur contenant le proxy d'authentification Cloud SQL sont disponibles sur GitHub dans le dépôt 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/cloudsql-docker/gce-proxy:1.30.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 plus d'informations 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 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.

Créez l'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 INSTANCE_NAME.
5. Indiquez le mot de passe de l'utilisateur postgres.
6. Conservez les valeurs par défaut des autres champs.
7. Cliquez sur Create (Créer).
La création de l'instance et la préparation à son utilisation prennent quelques minutes.
gcloud
- Créez l'instance PostgreSQL :
  gcloud sql instances create INSTANCE_NAME \ --project PROJECT_ID \ --database-version POSTGRES_13 \ --tier db-f1-micro \ --region REGION
Remplacez les éléments suivants :
- 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 et la préparation à son utilisation prennent quelques minutes.
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 Create database.
3. Dans la boîte de dialogue Nom de la base de données, saisissez DATABASE_NAME.
4. 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éez un utilisateur de base de données :

Remarque : Les utilisateurs créés de cette manière obtiennent des droits de base de données supplémentaires. Pour découvrir une autre méthode, consultez la section Limiter les droits d'utilisateur de la 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 Ajouter un compte utilisateur à l'instance, sous "Authentification intégrée", effectuez les opérations suivantes :
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é.

Créer un compte de service

Le proxy requiert un compte de service doté des droits Éditeur pour l'instance Cloud SQL. Pour en savoir plus sur les comptes de service, consultez la présentation de l'authentification sur Google Cloud.

Si vous vous connectez à partir de Compute Engine, assurez-vous que votre VM dispose du scope approprié pour se connecter à l'aide de l'API Cloud SQL Admin.

Configurez le compte de service pour lui donner l'un des niveaux d'accès suivants:

https://www.googleapis.com/auth/sqlservice.admin
https://www.googleapis.com/auth/cloud-platform

Dans Cloud Console, accédez à la page Comptes de service.
Accéder à la page "Comptes de service"
Sélectionnez le projet qui contient votre instance Cloud SQL.
Cliquez sur Créer un compte de service.
Dans le champ Nom du compte de service, attribuez un nom descriptif au compte de service.
Remplacez l'ID du compte de service par une valeur unique et facilement reconnaissable, puis cliquez sur Créer et continuer.
Cliquez sur le champ Sélectionner un rôle, puis sélectionnez l'un des rôles suivants :
- Cloud SQL > Client Cloud SQL
- Cloud SQL > Éditeur Cloud SQL
- Cloud SQL > Administrateur Cloud SQL
Cliquez sur OK pour terminer la création du compte de service.
Cliquez sur le menu Action de votre nouveau compte de service, puis sélectionnez Gérer les clés.
Cliquez sur le menu déroulant Ajouter une clé, puis sur Créer une clé.
Vérifiez que le type de clé est bien JSON et cliquez sur Créer.
Le fichier de clé privée est téléchargé sur votre machine. Vous pouvez le changer d'emplacement. Conservez le fichier de clé à un endroit sécurisé.

Configurer les paramètres de base de données

Utilisez les commandes suivantes pour définir les variables d'environnement pour l'accès à la base de données. Ces variables d'environnement permettent d'effectuer des tests en local.

Linux/MacOS

export DATABASE_NAME=DATABASE_NAME
export DATABASE_USER=DATABASE_USERNAME
export DATABASE_PASSWORD=DATABASE_PASSWORD

Windows

set DATABASE_USER=DATABASE_USERNAME
set DATABASE_PASSWORD=DATABASE_PASSWORD

Configurer votre environnement GKE

Cette application est représentée dans une seule configuration Kubernetes, appelée polls. Dans polls.yaml, remplacez <your-project-id> par l'ID de votre projet Google Cloud (PROJECT_ID).

Exécutez la commande suivante et copiez la valeur de connectionName :

gcloud sql instances describe INSTANCE_NAME --format "value(connectionName)"

Dans le fichier polls.yaml, remplacez <your-cloudsql-connection-string> par la valeur de connectionName que vous venez de copier.

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, la création d'un super-utilisateur et l'application de migrations de bases de données.

Dans un terminal distinct, démarrez le proxy d'authentification Cloud SQL :
Linux/macOS
```
./cloud_sql_proxy -instances="PROJECT_ID:REGION:INSTANCE_NAME"=tcp:5432
```
Windows
```
cloud_sql_proxy.exe -instances="PROJECT_ID:REGION:INSTANCE_NAME"=tcp:5432
```
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.

Dans un nouveau terminal, définissez l'ID de projet localement :

Linux/macOS

  export GOOGLE_CLOUD_PROJECT=PROJECT_ID

Windows

  set GOOGLE_CLOUD_PROJECT=PROJECT_ID

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

Démarrez le serveur Web Django :
```
python manage.py runserver
```
Dans votre navigateur, accédez à http://localhost:8000.

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.
Appuyez sur Ctrl/Cmd+C pour arrêter le serveur Web local.

Utiliser la console d'administration Django

Pour vous connecter à la console d'administration de Django, vous devez créer un super-utilisateur. Comme vous disposez d'une connexion locale à la base de données, vous pouvez exécuter les commandes de gestion :

Créez un super-utilisateur. Vous êtes invité à saisir un nom d'utilisateur, une adresse e-mail et un mot de passe.
```
python manage.py createsuperuser
```
Démarrez un serveur Web local :
```
python manage.py runserver
```
Dans votre navigateur, accédez à http://localhost:8000/admin.
Connectez-vous au site d'administration à l'aide du nom d'utilisateur et du mot de passe que vous avez spécifiés dans la commande createsuperuser.

Déployer l'application sur GKE

Lorsque l'application est déployée sur Google Cloud, elle utilise le serveur Gunicorn. Comme ce serveur ne peut pas diffuser de contenu statique, l'app doit utiliser Cloud Storage pour diffuser le contenu statique.

Collecter et importer les ressources statiques

Créez un bucket Cloud Storage et rendez-le lisible en mode public.

gsutil mb gs://PROJECT_ID_MEDIA_BUCKET
gsutil defacl set public-read gs://PROJECT_ID_MEDIA_BUCKET

Rassemblez tout le contenu statique localement dans un seul dossier :
```
python manage.py collectstatic
```

Importez le contenu statique dans Cloud Storage :

gsutil -m rsync -r ./static gs://PROJECT_ID_MEDIA_BUCKET/static

Dans le fichier mysite/settings.py, renseignez la valeur de STATIC_URL avec l'URL suivante, en prenant soin de remplacer [YOUR_GCS_BUCKET] par le nom de votre bucket :
```
http://storage.googleapis.com/PROJECT_ID_MEDIA_BUCKET/static/
```

Configurer GKE

Pour initialiser GKE, accédez à la page Clusters.

Accéder à la page "Clusters"

Lorsque vous utilisez GKE pour la première fois dans un projet, vous devez attendre que le message suivant disparaisse : "Kubernetes Engine is getting ready. This may take a minute or more" (Kubernetes Engine est en cours d'activation. Cette opération peut prendre une minute ou plus).
Créer un cluster GKE à l'aide de la commande suivante :
```
gcloud container clusters create polls \
  --scopes "https://www.googleapis.com/auth/userinfo.email","cloud-platform" \
  --num-nodes 4 --zone "us-central1-a"
```
Avez-vous obtenu l'erreur : Project [PROJECT_ID] is not fully initialized with the default service accounts (Le projet [PROJECT_ID] n'est pas complètement initialisé avec les comptes de service par défaut) ?

Initialiser GKE

Si vous avez reçu une erreur, accédez à Google Cloud Console pour initialiser GKE dans votre projet.

Accéder à la page "Clusters"

Attendez la disparition du message "Kubernetes Engine is getting ready. This may take a minute or more" (Kubernetes Engine est en cours d'activation. Cette opération peut prendre une minute ou plus).
Une fois votre cluster GKE créé, utilisez l'outil de ligne de commande kubectl, qui est intégré à gcloud, pour interagir avec le cluster. gcloud et kubectl étant des outils distincts, assurez-vous que kubectl est configuré pour interagir avec le cluster approprié.
```
gcloud container clusters get-credentials polls --zone "us-central1-a"
```

Configurer Cloud SQL

Vous avez besoin de plusieurs secrets pour permettre à l'application GKE de se connecter à l'instance Cloud SQL. L'un est requis pour l'accès au niveau de l'instance (connexion), tandis que les deux autres sont nécessaires pour l'accès à la base de données. Pour plus d'informations sur les deux niveaux de contrôle d'accès, consultez la page Contrôle d'accès aux instances.
1. Pour créer le secret permettant d'accéder à l'instance, utilisez la commande ci-dessous en indiquant l'emplacement ([PATH_TO_CREDENTIAL_FILE]) du fichiers JSON contenant la clé de compte de service. Vous avez dû télécharger ce fichier lors de la création du compte de service (voir la section Créer un compte de service) :
```
kubectl create secret generic cloudsql-oauth-credentials \
  --from-file=credentials.json=[PATH_TO_CREDENTIAL_FILE]
```
2. Pour créer les secrets permettant d'accéder à la base de données, utilisez la base de données SQL, le nom d'utilisateur et le mot de passe définis à l'étape 2 de la section Initialiser votre instance Cloud SQL :
```
kubectl create secret generic cloudsql \
  --from-literal=database=DATABASE_NAME \
  --from-literal=username=DATABASE_USERNAME \
  --from-literal=password=DATABASE_PASSWORD
```
Récupérez l'image Docker publique du proxy Cloud SQL.
```
docker pull b.gcr.io/cloudsql-docker/gce-proxy
```
Créez une image Docker en remplaçant <your-project-id> par l'ID de votre projet.
```
docker build -t gcr.io/PROJECT_ID/polls .
```
Configurez Docker pour utiliser gcloud en tant qu'assistant d'identification, afin de pouvoir transférer l'image vers Container Registry :
```
gcloud auth configure-docker
```
Envoyez l'image Docker. Remplacez <your-project-id> par l'ID du projet.
```
docker push gcr.io/PROJECT_ID/polls
```
Remarque : Cette commande nécessite un accès en écriture à Cloud Storage. Si vous exécutez ce tutoriel sur une instance Compute Engine, votre accès à Cloud Storage peut être en lecture seule. Pour obtenir un accès en écriture, créez un compte de service et utilisez-le pour vous authentifier sur votre instance.
Créez la ressource GKE :
```
kubectl create -f polls.yaml
```
Remarque : Si vous avez utilisé des noms différents (autres que cloudsql-oauth-credentials et cloudsql) lors de la création des secrets dans les commandes précédentes, vous devez mettre à jour le fichier polls.yaml pour qu'il corresponde à ces nouveaux noms.

Déployer l'application sur GKE

Une fois les ressources créées, le cluster contient trois pods polls. Vérifiez l'état des pods :

kubectl get pods

Attendez quelques minutes que les pods affichent l'état Running. Si les pods ne sont pas prêts ou nécessitent un redémarrage, vous pouvez obtenir les journaux d'un pod spécifique pour résoudre le problème. [YOUR-POD-ID] correspond à une partie du résultat renvoyé par la commande kubectl get pods précédente.

kubectl logs [YOUR_POD_ID]

Voir l'application en cours d'exécution dans Google Cloud

Une fois les modules prêts, vous pouvez obtenir l'adresse IP publique de l'équilibreur de charge :

kubectl get services polls

Notez l'adresse EXTERNAL-IP, puis accédez à http://[EXTERNAL-IP] dans votre navigateur pour afficher la page de destination des interrogations Django et accéder à la console d'administration.

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

Configuration de la base de données

Le fichier settings.py contient la configuration de la base de données SQL :

kubernetes_engine/django_tutorial/monsite/settings.py

Afficher sur GitHub

DATABASES = {
    'default': {
        # If you are using Cloud SQL for MySQL rather than PostgreSQL, set
        # 'ENGINE': 'django.db.backends.mysql' instead of the following.
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': os.getenv('DATABASE_NAME'),
        'USER': os.getenv('DATABASE_USER'),
        'PASSWORD': os.getenv('DATABASE_PASSWORD'),
        'HOST': '127.0.0.1',
        'PORT': '5432',
    }
}

Configurations de pod Kubernetes

Le fichier polls.yaml spécifie deux ressources Kubernetes. La première est le service, qui définit un nom cohérent et une adresse IP privée pour l'application Web Django. La seconde est un équilibreur de charge HTTP avec une adresse IP externe publique.

kubernetes_engine/django_tutorial/polls.yaml

Afficher sur GitHub

# The polls service provides a load-balancing proxy over the polls app
# pods. By specifying the type as a 'LoadBalancer', Kubernetes Engine will
# create an external HTTP load balancer.
# For more information about Services see:
#   https://kubernetes.io/docs/concepts/services-networking/service/
# For more information about external HTTP load balancing see:
#   https://kubernetes.io/docs/tasks/access-application-cluster/create-external-load-balancer/
apiVersion: v1
kind: Service
metadata:
  name: polls
  labels:
    app: polls
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app: polls

Le service fournit un nom de réseau et une adresse IP. Derrière cette façade, les pods GKE exécutent le code de l'application. Le fichier polls.yaml spécifie un déploiement qui contient les déclarations relatives aux pods GKE. Le service achemine le trafic vers le déploiement en mettant en correspondance le sélecteur du service et le libellé du déploiement. Dans le cas présent, il y a correspondance entre le sélecteur polls et le libellé polls.

kubernetes_engine/django_tutorial/polls.yaml

Afficher sur GitHub

apiVersion: apps/v1
kind: Deployment
metadata:
  name: polls
  labels:
    app: polls
spec:
  replicas: 3
  selector:
    matchLabels:
      app: polls
  template:
    metadata:
      labels:
        app: polls
    spec:
      containers:
      - name: polls-app
        # Replace  with your project ID or use `make template`
        image: gcr.io/<your-project-id>/polls
        # This setting makes nodes pull the docker image every time before
        # starting the pod. This is useful when debugging, but should be turned
        # off in production.
        imagePullPolicy: Always
        env:
            - name: DATABASE_NAME
              valueFrom:
                secretKeyRef:
                  name: cloudsql
                  key: database
            - name: DATABASE_USER
              valueFrom:
                secretKeyRef:
                  name: cloudsql
                  key: username
            - name: DATABASE_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: cloudsql
                  key: password
        ports:
        - containerPort: 8080

      - image: gcr.io/cloudsql-docker/gce-proxy:1.16
        name: cloudsql-proxy
        command: ["/cloud_sql_proxy", "--dir=/cloudsql",
                  "-instances=<your-cloudsql-connection-string>=tcp:5432",
                  "-credential_file=/secrets/cloudsql/credentials.json"]
        volumeMounts:
          - name: cloudsql-oauth-credentials
            mountPath: /secrets/cloudsql
            readOnly: true
          - name: ssl-certs
            mountPath: /etc/ssl/certs
          - name: cloudsql
            mountPath: /cloudsql
      volumes:
        - name: cloudsql-oauth-credentials
          secret:
            secretName: cloudsql-oauth-credentials
        - name: ssl-certs
          hostPath:
            path: /etc/ssl/certs
        - name: cloudsql
          emptyDir: {}

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

Attention : La suppression d'un projet entraîne les effets décrits ci-dessous :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Supprimer les ressources individuelles

Si vous ne souhaitez pas supprimer le projet, supprimez les ressources individuelles.

Supprimez le cluster Google Kubernetes Engine :
```
gcloud container clusters delete polls
```
Supprimez l'image Docker que vous avez transférée vers Container Registry :
```
gcloud container images delete gcr.io/PROJECT_ID/polls
```

Supprimez l'instance Cloud SQL :

gcloud sql instances delete INSTANCE_NAME

Étapes suivantes

Apprenez à configurer PostgreSQL pour la production.
Apprenez-en plus sur Django sur Google Cloud.

Exécuter Django sur Google Kubernetes Engine

Objectifs

Coûts

Avant de commencer

Préparer votre environnement

Cloner une application exemple

Linux/macOS

Windows

Confirmer la configuration de Python

Linux/macOS

Windows

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

Linux 64 bits

Linux 32 bits

macOS 64 bits

macOS 32 bits

Mac M1

Windows 64 bits

Windows 32 bits

Image Docker du proxy d'authentification Cloud SQL

Autres systèmes d'exploitation

Créer des services externes

Configurer une instance Cloud SQL pour PostgreSQL

Console

gcloud

Console

gcloud

Console

gcloud

Créer un compte de service

Configurer les paramètres de base de données

Linux/MacOS

Windows

Configurer votre environnement GKE

Exécuter l'application sur votre ordinateur local

Linux/macOS

Windows

Linux/macOS

Windows

Utiliser la console d'administration Django

Déployer l'application sur GKE

Collecter et importer les ressources statiques

Configurer GKE

Initialiser GKE

Configurer Cloud SQL

Déployer l'application sur GKE

Voir l'application en cours d'exécution dans Google Cloud

Comprendre le code

Exemple d'application

Configuration de la base de données

Configurations de pod Kubernetes

Effectuer un nettoyage

Supprimer le projet

Supprimer les ressources individuelles

Étapes suivantes