Exécuter Django sur Google Kubernetes Engine

Les applications Django qui s'exécutent sur Google Kubernetes Engine (GKE) sont capables de s'adapter, car elles s'exécutent sur la même infrastructure que tous les produits Google.

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. Dans ce tutoriel, 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

  1. Connectez-vous à votre compte Google.

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

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

    Accéder à la page de sélection du projet

  3. Vérifiez que la facturation est activée pour votre projet Google Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  4. Activer les API Cloud SQL, and Compute Engine.

    Activer les API

  5. Installez et initialisez le SDK Cloud.

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

Une fois les conditions préalables remplies, téléchargez et exécutez 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 :

    cd python-docs-samples/kubernetes_engine/django_tutorial

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.

Active l'API Cloud SQL Admin

Avant d'utiliser Cloud SQL, vous devez activer l'API Cloud SQL Admin à l'aide de la commande suivante :

gcloud services enable sqladmin

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

Pour télécharger le proxy, effectuez un clic droit sur 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, effectuez un clic droit sur 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.
Si votre système d'exploitation n'apparaît pas ici, vous pouvez également compiler le proxy à partir de la source.

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 le résultat, notez la valeur indiquée pour [CONNECTION_NAME].

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

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

    Cloud Console

    1. Créez une base de données à l'aide de Cloud Console dans l'instance Cloud SQL polls-instance. Vous pouvez par exemple utiliser le nom polls.
    2. Créez un utilisateur à l'aide de Cloud Console dans l'instance Cloud SQL polls-instance.

    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 la présentation de l'authentification sur Google Cloud.

Lorsque vous utilisez un compte de service pour fournir les identifiants du proxy, vous devez le créer avec des autorisations suffisantes. Si vous gérez vos autorisations Cloud SQL à l'aide des rôles IAM (Identity and Access Management), qui sont plus précis, vous devez attribuer au compte de service un rôle qui inclut l'autorisation "cloudsql.instances.connect". Voici les rôles Cloud SQL prédéfinis qui incluent cette autorisation :

  • Client Cloud SQL
  • Éditeur Cloud SQL
  • Administrateur Cloud SQL

Si vous utilisez les anciens rôles de projet (Lecteur, Éditeur, Propriétaire), le compte de service doit disposer au minimum du rôle Éditeur.

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

    Accéder à la page Comptes de service

  2. Sélectionnez le projet contenant l'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 facilement reconnaissable.
  7. Cliquez sur Indiquer une nouvelle clé privée et vérifiez que le type de clé est JSON.
  8. 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_USER=<your-database-user>
export DATABASE_PASSWORD=<your-database-password>

Windows

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

Configurer l'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 l'ID de votre projet Google Cloud.

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

    gcloud beta sql instances describe [YOUR_INSTANCE_NAME]

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

  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. Si votre installation Python 3 porte un nom différent, utilisez-le dans la première commande :

    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.

    Une page contenant le texte suivant s'affiche : "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.

  6. Appuyez sur Control+C pour arrêter le serveur Web local.

Utiliser la console d'administration Django

  1. Créez un super-utilisateur en spécifiant son nom d'utilisateur et son mot de passe.

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

  1. Créez un bucket Cloud Storage et rendez-le lisible en mode public. Remplacez [YOUR_GCS_BUCKET] par le 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 -m rsync -r ./static gs://[YOUR_GCS_BUCKET]/static

  4. 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/[YOUR_GCS_BUCKET]/static/

Configurer GKE

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

  2. 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 un message d'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).

  3. 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, qui est 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"

Configurer Cloud SQL

  1. 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 commande suivante en reprenant les paramètres SQL [PROXY_USERNAME] et [PASSWORD] définis à l'étape 2 de la section Initialiser votre instance Cloud SQL :

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

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

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

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

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

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

  5. Envoyez l'image Docker. Remplacez <your-project-id> par l'ID du projet.

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

  6. Créez la ressource GKE :

    kubectl create -f polls.yaml

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 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 : [YOUR-POD-ID] fait partie du résultat renvoyé par la commande kubectl get pods précédente.

    kubectl logs [YOUR_POD_ID]

Afficher l'application exécutée 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

Accédez à l'adresse EXTERNAL-IP avec le navigateur. La page de destination de base de Django s'affiche et vous pouvez 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

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

kubernetes_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',
    }
}

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