Exécuter Django sur Kubernetes Engine

Vous pouvez facilement commencer à développer des applications Django qui s'exécutent sur Google Kubernetes Engine. Comme les applications créées sont exécutées sur l'infrastructure sur laquelle sont basés tous les produits Google, vous avez la garantie d'un dimensionnement efficace, à même de desservir l'ensemble de vos utilisateurs, qu'ils soient une poignée ou plusieurs millions.

Dans ce tutoriel, nous partons du principe que vous connaissez bien le développement Web avec Django. L'objectif est ici de vous guider lors du déploiement de l'application de tutoriel Django officielle.

Il est recommandé de parcourir ce tutoriel avant celui-ci, en particulier si vous débutez dans le développement avec Django. Les modèles de l'application représentent des sondages contenant des questions. Vous pouvez interagir avec ces modèles à l'aide de la console d'administration Django.

Ce tutoriel nécessite Python 2.7, 3.4 ou une version ultérieure. Vous devez également avoir installé Docker.

Avant de commencer

Cochez les étapes à mesure que vous les effectuez.

  1. check_box_outline_blank check_box Créez un projet dans la console Google Cloud Platform.
    Si ce n'est pas déjà fait, créez un projet maintenant. Les projets vous permettent de gérer toutes les ressources Google Cloud Platform pour votre application, y compris le déploiement, le contrôle des accès, la facturation et les services.
    1. Ouvrez la console GCP.
    2. Dans le menu déroulant en haut de l'écran, sélectionnez Créer un projet.
    3. Cliquez sur Afficher les options avancées. Sous App Engine location (Emplacement du site App Engine), sélectionnez un emplacement basé aux États-Unis.
    4. Attribuez un nom à votre projet.
    5. Notez l'ID du projet, qui peut être différent du nom du projet. Cet ID est utilisé dans les commandes et dans les configurations.
  2. check_box_outline_blank check_box Activez la facturation pour votre projetet souscrivez un essai gratuit.

    Si ce n'est pas encore fait, activez la facturation pour votre projetet inscrivez-vous à l'essai gratuit. L'activation de la facturation permet à l'application de consommer des ressources facturables, telles que l'exécution d'instances et le stockage de données. Pendant votre période d'essai gratuit, aucun service ne vous sera facturé.

  3. check_box_outline_blank check_box Installez le SDK Cloud.

    Si ce n'est pas déjà fait, installez le SDK Cloud et initialisez-le maintenant. Le SDK Cloud contient des outils et des bibliothèques qui vous permettent de créer et gérer des ressources sur GCP.

  4. check_box_outline_blank check_box Activez les API pour votre projet.

    Vous êtes alors dirigé vers la console GCP et les API utilisées par ce tutoriel sont automatiquement activées. Les API utilisées sont Cloud SQL et Compute Engine.

Télécharger et exécuter l'application

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 l'exemple.

Cloner l'application Django

Le code de l'exemple d'application Django se trouve dans le dépôt GitHub GCP Python Samples.

Clonez le dépôt sur votre machine locale :

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

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

cd python-docs-samples/container_engine/django_tutorial

Vous pouvez également télécharger l'exemple en tant que fichier zip et l'extraire.

Configurer votre environnement local

Une fois déployée, votre application communique avec votre instance Cloud SQL via le proxy Cloud SQL intégré à l'environnement App 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.

Apprenez-en plus sur le proxy Cloud SQL.

Pour effectuer des tâches administratives de base sur votre instance Cloud SQL, vous pouvez utiliser le client PostgreSQL.

Installer le proxy Cloud SQL

Téléchargez et installez le proxy Cloud SQL. Le proxy Cloud SQL se connecte à votre instance Cloud SQL lorsqu'il est exécuté en local.

Linux 64 bits

  1. Téléchargez le proxy : 
    wget https://dl.google.com/cloudsql/cloud_sql_proxy.linux.amd64 -O cloud_sql_proxy
  2. Rendez le proxy exécutable : 
    chmod +x cloud_sql_proxy

Linux 32 bits

  1. Téléchargez le proxy : 
    wget https://dl.google.com/cloudsql/cloud_sql_proxy.linux.386 -O cloud_sql_proxy
  2. Rendez le proxy exécutable : 
    chmod +x cloud_sql_proxy

macOS 64 bits

  1. Téléchargez le proxy : 
    curl -o cloud_sql_proxy https://dl.google.com/cloudsql/cloud_sql_proxy.darwin.amd64
  2. Rendez le proxy exécutable : 
    chmod +x cloud_sql_proxy

macOS 32 bits

  1. Téléchargez le proxy : 
    curl -o cloud_sql_proxy https://dl.google.com/cloudsql/cloud_sql_proxy.darwin.386
  2. Rendez le proxy exécutable : 
    chmod +x cloud_sql_proxy

Windows 64 bits

Cliquez avec le bouton droit de la souris sur https://dl.google.com/cloudsql/cloud_sql_proxy_x64.exe et sélectionnez Enregistrer le lien sous pour télécharger le proxy. Renommez le fichier en cloud_sql_proxy.exe.

Windows 32 bits

Cliquez avec le bouton droit sur https://dl.google.com/cloudsql/cloud_sql_proxy_x86.exe et sélectionnez Enregistrer le lien sous pour télécharger le proxy. Renommez le fichier en cloud_sql_proxy.exe.
Si votre système d'exploitation n'est pas présenté ici, vous pouvez également compiler le proxy à partir des sources.

Créer une instance Cloud SQL

  1. Créez une instance Cloud SQL pour PostgreSQL.

    Nommez-la polls-instance ou donnez-lui un nom similaire. La préparation de l'instance peut prendre quelques minutes. Lorsqu'elle est prête, elle est visible dans la liste des instances.

  2. Utilisez à présent le SDK Cloud pour exécuter la commande suivante, en remplaçant [YOUR_INSTANCE_NAME] par le nom de votre instance Cloud SQL. 
    gcloud sql instances describe [YOUR_INSTANCE_NAME]

    Dans la sortie, notez la valeur indiquée pour [CONNECTION_NAME].

    La valeur de [CONNECTION_NAME] est au format [PROJECT_NAME]:[REGION_NAME]:[INSTANCE_NAME].

Initialisation de votre instance Cloud SQL

  1. Démarrez le proxy Cloud SQL en utilisant la valeur [CONNECTION_NAME] de l'étape précédente.

    Linux/macOS

    ./cloud_sql_proxy -instances="[YOUR_INSTANCE_CONNECTION_NAME]"=tcp:5432

    Windows

    cloud_sql_proxy.exe -instances="[YOUR_INSTANCE_CONNECTION_NAME]"=tcp:5432

    Remplacez [YOUR_INSTANCE_CONNECTION_NAME] par la valeur [CONNECTION_NAME] que vous avez enregistrée à l'étape précédente.

    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 Cloud SQL lors du test local de votre application.

  2. Créez un utilisateur et une base de données Cloud SQL.

    Console GCP

    1. Créez une nouvelle base de données à l'aide de la console GCP pour votre instance polls-instance Cloud SQL. Par exemple, vous pouvez utiliser le nom polls.
    2. Créez un nouvel utilisateur à l'aide de la console GCP pour votre instance polls-instance Cloud SQL.

    Client Postgres

    1. Dans un onglet de ligne de commande distinct, installez le client Postgres. 
      sudo apt-get install postgresql
    2. Utilisez le client Postgres ou un programme similaire pour vous connecter à votre instance. Lorsque vous y êtes invité, saisissez le mot de passe racine que vous avez configuré. 
      psql --host 127.0.0.1 --user postgres --password
    3. Créez les bases de données, les utilisateurs et les autorisations d'accès nécessaires dans votre base de données Cloud SQL à l'aide des commandes suivantes. Remplacez [POSTGRES_USER] et [POSTGRES_PASSWORD] par le nom d'utilisateur et le mot de passe que vous souhaitez utiliser. 
      CREATE DATABASE polls;
CREATE USER [POSTGRES_USER] WITH PASSWORD '[POSTGRES_PASSWORD]';
GRANT ALL PRIVILEGES ON DATABASE polls TO [POSTGRES_USER];
GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO [POSTGRES_USER];

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 le guide d'authentification GCP.

  1. Accédez à la page Comptes de service de la console Google Cloud Platform.

    Accéder à la page "Comptes de service"

  2. Si nécessaire, sélectionnez le projet contenant votre instance Cloud SQL.
  3. Cliquez sur Créer un compte de service.
  4. Dans la boîte de dialogue "Créer un compte de service", indiquez un nom descriptif pour le compte de service.
  5. Pour Rôle, sélectionnez l'un des rôles suivants :
    • Cloud SQL > Client Cloud SQL
    • Cloud SQL > Éditeur Cloud SQL
    • Cloud SQL > Administrateur Cloud SQL
  6. Remplacez l'ID du compte de service par une valeur unique et reconnaissable. Si vous avez besoin du compte ultérieurement, vous pourrez ainsi le retrouver facilement.
  7. Cliquez sur Indiquer une nouvelle clé privée.
  8. Le type de clé par défaut est JSON, ce qui correspond à la valeur correcte à utiliser.
  9. 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

  1. Définissez les variables d'environnement d'accès à la base de données pour les tests locaux.

Linux/macOS

export DATABASE_USER=<your-database-user>
export DATABASE_PASSWORD=<your-database-password>

Windows

set DATABASE_USER=<your-database-user>
set DATABASE_PASSWORD=<your-database-password>

Configurer votre environnement GKE

  1. Cette application est représentée dans une seule configuration Kubernetes, appelée polls. Dans polls.yaml, remplacez <your-project-id> par votre ID de projet.

  2. Dans polls.yaml, remplacez <your-cloudsql-connection-string> par la valeur de connectionName renvoyée par la commande suivante :

    gcloud beta sql instances describe [YOUR_INSTANCE_NAME]

Exécuter l'application sur votre ordinateur local

  1. Pour exécuter l'application Django sur votre ordinateur local, configurez un environnement de développement Python incluant Python, pip et virtualenv.

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

    virtualenv env
source env/bin/activate
pip install -r requirements.txt

  3. Exécutez les migrations Django pour configurer vos modèles :

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

  4. Démarrez un serveur Web local :

    python manage.py runserver

  5. Dans votre navigateur, accédez à http://localhost:8000.

Vous devez voir une simple page Web affichant le texte suivant : "Hello, world. You're at the polls index." Les pages de l'exemple d'application sont diffusées par le serveur Web Django exécuté sur votre ordinateur. Lorsque vous êtes prêt à poursuivre, appuyez sur les touches Ctrl+C pour arrêter le serveur Web local.

Utiliser la console d'administration Django

  1. Créez un super-utilisateur :

    python manage.py createsuperuser

  2. Exécutez le programme principal :

    python manage.py runserver

  3. Dans votre navigateur, accédez à http://localhost:8000/admin.

  4. Connectez-vous au site d'administration à l'aide du nom d'utilisateur et du mot de passe que vous avez créés lorsque vous avez exécuté createsuperuser.

Déployer l'application sur GKE

  1. Lorsque l'application est déployée sur Cloud Platform, elle utilise le serveur Gunicorn. Elle diffuse du contenu statique via Cloud Storage, car Gunicorn ne propose pas cette fonction.

    Créez un bucket Cloud Storage et rendez-le lisible en mode public. Remplacez <your-gcs-bucket> par un nom de bucket de votre choix. Par exemple, vous pouvez utiliser votre ID de projet :

    gsutil mb gs://<your-gcs-bucket>
gsutil defacl set public-read gs://<your-gcs-bucket>

  2. Rassemblez tout le contenu statique localement dans un seul dossier :

    python manage.py collectstatic

  3. Importez le contenu statique dans Cloud Storage :

    gsutil rsync -R static/ gs://<your-gcs-bucket>/static

  4. Dans mysite/settings.py, définissez STATIC_URL sur cette URL en remplaçant <your-gcs-bucket> par le nom de bucket.

    http://storage.googleapis.com/<your-gcs-bucket>/static/

  5. Pour initialiser GKE, accédez à la console GCP. 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).

  6. Créez un cluster GKE : 

    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 {container_name_short}}

    Si vous avez reçu une erreur, accédez à la console pour initialiser GKE dans votre projet :

    Accéder à la page GKE

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

  7. Une fois que vous avez créé le cluster GKE, vous pouvez interagir avec celui-ci à l'aide de l'outil de ligne de commande kubectl intégré à l'outil gcloud. 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"

  8. 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 pour l'accès au niveau de l'instance, indiquez l'emplacement de la clé que vous avez téléchargée lors de la création de votre compte de service :

      kubectl create secret generic cloudsql-oauth-credentials --from-file=credentials.json=[PATH_TO_CREDENTIAL_FILE]

    2. Créez les secrets nécessaires pour accéder à la base de données :

      kubectl create secret generic cloudsql --from-literal=username=[PROXY_USERNAME] --from-literal=password=[PASSWORD]

  9. Récupérez l'image Docker publique du proxy Cloud SQL.

    docker pull b.gcr.io/cloudsql-docker/gce-proxy:1.05

  10. Créez une image Docker en remplaçant <your-project-id> par votre ID de projet.

    docker build -t gcr.io/<your-project-id>/polls .

  11. Configurez docker pour utiliser gcloud comme assistant d'identification, afin de pouvoir transférer l'image à Google Container Registry :

    gcloud auth configure-docker

  12. Envoyez l'image Docker. Remplacez <your-project-id> par votre ID de projet.

    docker push gcr.io/<your-project-id>/polls

  13. Créez la ressource GKE :

    kubectl create -f polls.yaml

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

    kubectl get pods

    Attendez quelques minutes que les pods passent à l'état Running. Si un pod n'est pas prêt ou nécessite un redémarrage, vous pouvez obtenir ses journaux pour résoudre le problème :

    kubectl logs <your-pod-id>

Voir l'application exécutée dans GCP

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

kubectl get services polls

Accédez à l'adresse EXTERNAL-IP de votre navigateur pour afficher la page de destination de base de Django et accéder à la console d'administration.

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

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

container_engine/django_tutorial/mysite/settings.py 
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': 'polls',
        'USER': os.getenv('DATABASE_USER'),
        'PASSWORD': os.getenv('DATABASE_PASSWORD'),
        'HOST': '127.0.0.1',
        'PORT': '5432',
    }
}

Les fichiers polls.yaml spécifient deux ressources Kubernetes. Le premier est le service qui définit un nom cohérent et une adresse IP privée pour l'application Web Django. Le second est un équilibreur de charge HTTP avec une adresse IP externe publique.

container_engine/django_tutorial/polls.yaml 
# The polls service provides a load-balancing proxy over the polls app
# pods. By specifying the type as a 'LoadBalancer', Container Engine will
# create an external HTTP load balancer.
# For more information about Services see:
#   https://cloud.google.com/container-engine/docs/services/
# For more information about external HTTP load balancing see:
#   https://cloud.google.com/container-engine/docs/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, et les pods GKE exécutent le code d'application derrière le service. Le fichier polls.yaml spécifie un déploiement fournissant des mises à jour déclaratives pour les pods GKE. Le service dirige le trafic vers le déploiement en mettant en correspondance le sélecteur du service et le libellé du déploiement. Dans ce cas, l'élément polls du sélecteur est associé à l'élément polls du libellé.

container_engine/django_tutorial/polls.yaml 
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: polls
  labels:
    app: polls
spec:
  replicas: 3
  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_USER
              valueFrom:
                secretKeyRef:
                  name: cloudsql
                  key: username
            - name: DATABASE_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: cloudsql
                  key: password
        ports:
        - containerPort: 8080

      - image: b.gcr.io/cloudsql-docker/gce-proxy:1.05
        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:
Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Cette page
Commentaires sur la documentation
Python
Commentaires sur le produit