Partager via

Tutoriel : Déployer l’application Django sur AKS avec Azure Database pour PostgreSQL – Serveur flexible

  • Article

S’APPLIQUE À : Azure Database pour PostgreSQL : serveur flexible

Dans ce démarrage rapide, vous déployez une application Django sur un cluster AKS (Azure Kubernetes Service) avec un serveur flexible Azure Database pour PostgreSQL à l’aide d’Azure CLI.

AKS est un service Kubernetes managé qui vous permet de déployer et gérer rapidement des clusters. Un serveur flexible Azure Database pour PostgreSQL est un service de base de données complètement managé conçu pour offrir un contrôle et une flexibilité plus granulaires des fonctions de gestion de base de données et des paramètres de configuration.

Remarque

Ce guide de démarrage rapide suppose une compréhension élémentaire des concepts liés à Kubernetes, Django et PostgreSQL.

Conditions préalables

Si vous n’avez pas d’abonnement Azure, créez un compte gratuit Azure avant de commencer.

  • Lancez Azure Cloud Shell dans une nouvelle fenêtre de navigateur. Vous pouvez également installer Azure CLI sur votre ordinateur local. Si vous utilisez une installation locale, connectez-vous à Azure CLI à l’aide de la commande az login. Pour finir le processus d’authentification, suivez les étapes affichées dans votre terminal.
  • Exécutez az version pour rechercher la version et les bibliothèques dépendantes installées. Pour effectuer une mise à niveau vers la dernière version, exécutez az upgrade. Cet article nécessite la dernière version d’Azure CLI. Si vous utilisez Azure Cloud Shell, sachez que la version la plus récente est déjà installée.

Créer un groupe de ressources

Un groupe de ressources Azure est un groupe logique dans lequel des ressources Azure sont déployées et gérées. Créons un groupe de ressources, django-project, à l’aide de la commande az-group-create à l’emplacement eastus.

az group create --name django-project --location eastus

Notes

L’emplacement du groupe de ressources correspond à l’endroit où sont stockées les métadonnées du groupe de ressources. C’est également là que vos ressources s’exécutent dans Azure si vous ne spécifiez pas une autre région lors de la création des ressources.

L’exemple de sortie suivant montre que le groupe de ressources a été créé correctement :

{
  "id": "/subscriptions/<guid>/resourceGroups/django-project",
  "location": "eastus",
  "managedBy": null,
  
  "name": "django-project",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null
}

Créer un cluster AKS

Utilisez la commande az aks create pour créer un cluster AKS. L’exemple suivant crée un cluster mononœud nommé djangoappcluster. L’exécution de cette commande prend plusieurs minutes.

az aks create --resource-group django-project --name djangoappcluster --node-count 1 --generate-ssh-keys

Au bout de quelques minutes, la commande se termine et retourne des informations au format JSON sur le cluster.

Notes

Lors de la création d’un cluster AKS, un deuxième groupe de ressources est automatiquement créé pour stocker les ressources AKS. Consultez Pourquoi deux groupes de ressources sont-ils créés avec AKS ?

Se connecter au cluster

Pour gérer un cluster Kubernetes, vous utilisez kubectl, le client de ligne de commande Kubernetes. Si vous utilisez Azure Cloud Shell, kubectl est déjà installé.

Remarque

Si vous exécutez Azure CLI localement, exécutez la commande az aks install-cli pour installer kubectl.

Pour configurer kubectl afin de vous connecter à votre cluster Kubernetes, exécutez la commande az aks get-credentials. Cette commande télécharge les informations d’identification et configure l’interface CLI Kubernetes pour les utiliser.

az aks get-credentials --resource-group django-project --name djangoappcluster

Pour vérifier la connexion à votre cluster, utilisez la commande kubectl get pour retourner une liste des nœuds du cluster.

kubectl get nodes

L’exemple de sortie suivant montre le nœud unique créé au cours des étapes précédentes. Vérifiez que l’état du nœud est Ready :

NAME                       STATUS   ROLES   AGE     VERSION
aks-nodepool1-31718369-0   Ready    agent   6m44s   v1.12.8

Créer une instance de serveur flexible Azure Database pour PostgreSQL

Créez une instance de serveur flexible Azure Database pour PostgreSQL avec la commande az postgreSQL flexible-server create. La commande suivante crée un serveur en utilisant les valeurs par défaut du service et les valeurs issues du contexte local de votre interface Azure CLI :

az postgres flexible-server create --public-access all

Le serveur créé possède les attributs suivants :

  • Une nouvelle base de données vide, postgres, est créée au moment du provisionnement initial du serveur. Dans ce guide de démarrage rapide, nous utilisons cette base de données.
  • Nom du serveur généré automatiquement, nom d’utilisateur administrateur, mot de passe administrateur, nom du groupe de ressources (s’il n’est pas déjà spécifié dans le contexte local) et même emplacement que votre groupe de ressources.
  • L’utilisation de l’argument public-access vous permet de créer un serveur avec un accès public à n’importe quel client avec un nom d’utilisateur et un mot de passe corrects.
  • Étant donné que la commande utilise le contexte local, elle crée le serveur dans le groupe de ressources django-project et dans la région eastus.

Générer votre image Docker Django

Créez une nouvelle application Django ou utilisez votre projet Django existant. Assurez-vous que votre code se trouve dans cette structure de dossiers.

└───my-djangoapp
    └───views.py
    └───models.py
    └───forms.py
    ├───templates
          . . . . . . .
    ├───static
         . . . . . . .
└───my-django-project
    └───settings.py
    └───urls.py
    └───wsgi.py
        . . . . . . .
    └─── Dockerfile
    └─── requirements.txt
    └─── manage.py

Mettez à jour ALLOWED_HOSTS dans settings.py pour vous assurer que l’application Django utilise l’adresse IP externe qui est assignée à l’application Kubernetes.

ALLOWED_HOSTS = ['*']

Mettez à jour la section DATABASES={ } dans le fichier settings.py. L’extrait de code ci-dessous lit l’hôte de base de données, le nom d’utilisateur et le mot de passe dans le fichier manifeste Kubernetes.

DATABASES={
   'default':{
      'ENGINE':'django.db.backends.postgresql_psycopg2',
      'NAME':os.getenv('DATABASE_NAME'),
      'USER':os.getenv('DATABASE_USER'),
      'PASSWORD':os.getenv('DATABASE_PASSWORD'),
      'HOST':os.getenv('DATABASE_HOST'),
      'PORT':'5432',
      'OPTIONS': {'sslmode': 'require'}
   }
}

Générer un fichier requirements.txt

Créez un fichier requirements.txt pour répertorier les dépendances pour l’application Django. Voici un exemple de fichier requirements.txt. Vous pouvez utiliser pip freeze > requirements.txt pour générer un fichier requirements.txt pour votre application existante.

Django==2.2.17
postgres==3.0.0
psycopg2-binary==2.8.6
psycopg2-pool==1.1
pytz==2020.4

Créer un Dockerfile

Créez un nouveau fichier nommé Dockerfile et copiez l’extrait de code ci-dessous. Ce fichier Dockerfile est utilisé dans la configuration de Python 3.8 et l’installation de tous les éléments requis listés dans le fichier requirements.txt.

# Use the official Python image from the Docker Hub

FROM python:3.8.2

# Make a new directory to put our code in.

RUN mkdir /code

# Change the working directory.

WORKDIR /code

# Copy to code folder

COPY . /code/

# Install the requirements.

RUN pip install -r requirements.txt

# Run the application:

CMD python manage.py runserver 0.0.0.0:8000

Créer votre image

Vérifiez que vous êtes dans le répertoire my-django-app sur un terminal à l’aide de la commande cd. Exécutez la commande suivante pour générer votre image de tableau d’affichage :

docker build --tag myblog:latest .

Déployez votre image sur Docker Hub ou Azure Container Registry.

Important

Si vous utilisez Azure Container Registry (ACR), exécutez la commande az aks update pour attacher le compte ACR au cluster AKS.

az aks update --name djangoappcluster --resource-group django-project --attach-acr <your-acr-name>

Créer un fichier manifeste Kubernetes

Un fichier manifeste Kubernetes définit un état souhaité pour le cluster, notamment les images conteneur à exécuter. Nous allons créer un fichier manifeste nommé djangoapp.yaml, et y copier la définition YAML suivante.

Important

Mettez à jour la section env ci-dessous avec vos SERVERNAME, YOUR-DATABASE-USERNAME et YOUR-DATABASE-PASSWORD de votre instance de serveur flexible Azure Database pour PostgreSQL.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: django-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: django-app
  template:
    metadata:
      labels:
        app: django-app
    spec:
      containers:
      - name: django-app
        image: [DOCKER-HUB-USER-OR-ACR-ACCOUNT]/[YOUR-IMAGE-NAME]:[TAG]
        ports:
        - containerPort: 8000
        env:
        - name: DATABASE_HOST
          value: "SERVERNAME.postgres.database.azure.com"
        - name: DATABASE_USER
          value: "YOUR-DATABASE-USERNAME"
        - name: DATABASE_PASSWORD
          value: "YOUR-DATABASE-PASSWORD"
        - name: DATABASE_NAME
          value: "postgres"
      affinity:
        podAntiAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            - labelSelector:
                matchExpressions:
                  - key: "app"
                    operator: In
                    values:
                    - django-app
              topologyKey: "kubernetes.io/hostname"
---
apiVersion: v1
kind: Service
metadata:
  name: python-svc
spec:
  type: LoadBalancer
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8000
  selector:
    app: django-app

Déployer Django sur le cluster AKS

Déployez l’application à l’aide de la commande kubectl apply et spécifiez le nom de votre manifeste YAML :

kubectl apply -f djangoapp.yaml

L’exemple de sortie suivant montre que les déploiements et les ressources ont été créés correctement :

deployment "django-app" created
service "python-svc" created

Un déploiement django-app vous permet de décrire les détails de votre déploiement, tels que les images à utiliser pour l’application, le nombre de pods et la configuration des pods. Un service python-svc est créé pour exposer l’application via une adresse IP externe.

Test de l’application

Quand l’application s’exécute, un service Kubernetes expose le front-end de l’application sur Internet. L’exécution de ce processus peut prendre plusieurs minutes.

Pour surveiller la progression, utilisez la commande kubectl get service avec l’argument --watch.

kubectl get service python-svc --watch

Dans un premier temps, la valeur EXTERNAL-IP pour le service django-app apparaît comme étant en attente.

NAME               TYPE           CLUSTER-IP   EXTERNAL-IP   PORT(S)        AGE
django-app   LoadBalancer   10.0.37.27   <pending>     80:30572/TCP   6s

Quand l’adresse EXTERNAL-IP passe de l’état pending à une adresse IP publique réelle, utilisez CTRL-C pour arrêter le processus de surveillance kubectl. L’exemple de sortie suivant montre une adresse IP publique valide affectée au service :

django-app  LoadBalancer   10.0.37.27   52.179.23.131   80:30572/TCP   2m

À présent, ouvrez un navigateur web à l’adresse IP externe de votre service (http://<service-external-ip-address>) et affichez l’application Django.

Remarque

Exécuter des migrations de base de données

Pour toute application Django, vous devez exécuter la migration de base de données ou collecter des fichiers statiques. Vous pouvez exécuter ces commandes de l’interpréteur de commandes Django avec $ kubectl exec <pod-name> -- [COMMAND]. Avant d’exécuter cette commande, vous devez rechercher le nom du pod avec kubectl get pods.

$ kubectl get pods

Vous obtenez un résultat similaire à ceci :

NAME                             READY   STATUS          RESTARTS   AGE
django-app-5d9cd6cd8-l6x4b     1/1     Running              0       2m

Une fois que le nom du pod a été trouvé, vous pouvez exécuter des migrations de base de données Django à l’aide de la commande $ kubectl exec <pod-name> -- [COMMAND]. Notez que /code/ est le répertoire de travail du projet défini dans Dockerfile ci-dessus.

$ kubectl exec django-app-5d9cd6cd8-l6x4b -- python /code/manage.py migrate

La sortie doit ressembler à ceci :

Operations to perform:
  Apply all migrations: admin, auth, contenttypes, sessions
Running migrations:
  Applying contenttypes.0001_initial... OK
  Applying auth.0001_initial... OK
  Applying admin.0001_initial... OK
  Applying admin.0002_logentry_remove_auto_add... OK
  Applying admin.0003_logentry_add_action_flag_choices... OK
  . . . . . .

Si vous rencontrez des problèmes, exécutez kubectl logs <pod-name> pour voir l’exception que lève votre application. Si l’application fonctionne correctement, une sortie semblable à celle-ci doit s’afficher lorsque vous exécutez kubectl logs.

Watching for file changes with StatReloader
Performing system checks...

System check identified no issues (0 silenced).

You have 17 unapplied migration(s). Your project may not work properly until you apply the migrations for app(s): admin, auth, contenttypes, sessions.
Run 'python manage.py migrate' to apply them.
December 08, 2020 - 23:24:14
Django version 2.2.17, using settings 'django_postgres_app.settings'
Starting development server at http://0.0.0.0:8000/
Quit the server with CONTROL-C.

Nettoyer les ressources

Pour éviter des frais Azure, vous devez nettoyer les ressources inutiles. Lorsque vous n’avez plus besoin du cluster, utilisez la commande az group delete pour supprimer le groupe de ressources, le service conteneur et toutes les ressources associées.

az group delete --name django-project --yes --no-wait

Remarque

Lorsque vous supprimez le cluster, le principal de service Microsoft Entra utilisé par le cluster AKS n’est pas supprimé. Pour obtenir des instructions sur la façon de supprimer le principal de service, consultez Considérations et suppression du principal de service AKS. Si vous avez utilisé une identité managée, l’identité est managée par la plateforme et n’a pas besoin d’être supprimée.

Étapes suivantes