Deployer Django sur Azure

Pourquoi Deployer Django sur Azure ?

Deploier Django sur Azure offre plusieurs avantages réels :

1. Échelle et performances : Azure permet de gérer l'échelle automatiquement en fonction de la charge du trafic, garantissant des performances optimales même sous un fort débit.
2. Sécurité : Les services Azure offrent une couche supplémentaire de sécurité avec des mesures intégrées pour protéger les applications contre diverses menaces.
3. Mise à jour et maintenance : Azure offre des mises à jour régulières et automatisées, ce qui permet de rester à jour en toute sécurité avec les derniers correctifs de sécurité et d'améliorations.

Un cas d'usage concret serait de développer une application web de gestion de tâches pour une petite entreprise. Avec Django sur Azure, cette application peut facilement s'écheller à plusieurs utilisateurs simultanés tout en conservant un haut niveau de performance et de sécurité.

Prerequis

Pour suivre ce tutoriel, vous aurez besoin des éléments suivants :

• Connaissance de base de Python
• Connaissances avancées de Django
• Un compte Azure avec une machine virtuelle Linux (Ubuntu)
• Git pour versionner votre code
• Virtualenv pour gérer les environnements virtuels

Concepts fondamentaux

1. Environnement virtuel et gestion des dépendances

Pour maintenir un environnement propre et isolé, il est recommandé d'utiliser un environnement virtuel. Voici comment créer et activer un environnement virtuel :

## Créer un environnement virtuel
python3 -m venv myenv

## Activer l'environnement virtuel (Linux/macOS)
source myenv/bin/activate

## Activer l'environnement virtuel (Windows)
myenv\Scripts\activate

2. Configuration de la machine virtuelle Azure

Assurez-vous que votre machine virtuelle Azure est configurée avec les éléments suivants :

• Un système d'exploitation Linux (Ubuntu recommandé)
• Python 3.x installé
• Git installé

3. Déploiement via SSH et Git

Utilisez SSH pour vous connecter à votre machine virtuelle Azure et configurez un dépôt Git local.

## Se connecter à la machine virtuelle Azure via SSH
ssh username@your_vm_ip_address

## Installer Git si ce n'est pas déjà fait
sudo apt-get update
sudo apt-get install git

4. Création d'un nouveau projet Django

Dans votre environnement virtuel, créez un nouveau projet Django.

## Créer un nouveau projet Django
django-admin startproject myproject
cd myproject

## Installer les dépendances nécessaires (exemple : psycopg2 pour PostgreSQL)
pip install django psycopg2-binary gunicorn

5. Configuration du fichier settings.py

Ajustez le fichier myproject/settings.py pour vous connecter à une base de données et configurer d'autres paramètres.

## myproject/settings.py

import os

## Sécurisation des cookies
SECRET_KEY = 'your_secret_key'

## Base de données (utilisez PostgreSQL)
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydatabase',
        'USER': 'myuser',
        'PASSWORD': 'mypassword',
        'HOST': 'localhost',
        'PORT': '',
    }
}

6. Configuration de Gunicorn

Gunicorn est un serveur WSGI pour Python, utilisé ici pour exécuter notre application Django.

## Créer un fichier systemd pour Gunicorn
sudo nano /etc/systemd/system/myproject.service

## Contenu du fichier myproject.service
[Unit]
Description=gunicorn daemon
After=network.target

[Service]
User=username
Group=www-data
WorkingDirectory=/home/username/myproject
Environment="PATH=/home/username/myenv/bin"
ExecStart=/home/username/myenv/bin/gunicorn --workers 3 --bind unix:myproject.sock myproject.wsgi:application

[Install]
WantedBy=multi-user.target

7. Configuration de Nginx

Nginx sera utilisé comme serveur web principal pour servir les requêtes HTTP.

## Installer Nginx
sudo apt-get install nginx

## Configurer Nginx
sudo nano /etc/nginx/sites-available/myproject

## Contenu du fichier myproject
server {
    listen 80;
    server_name your_domain_or_ip;

    location = /favicon.ico { access_log off; log_not_found off; }
    location /static/ {
        root /home/username/myproject;
    }

    location / {
        include proxy_params;
        proxy_pass http://unix:/home/username/myproject/myproject.sock;
    }
}

8. Activation de la configuration Nginx

Activez la configuration Nginx et redémarrez le service.

## Créer un lien symbolique vers les sites en production
sudo ln -s /etc/nginx/sites-available/myproject /etc/nginx/sites-enabled

## Tester la configuration Nginx
sudo nginx -t

## Redémarrer Nginx
sudo systemctl restart nginx

Mise en pratique : projet fil rouge

1. Création du mini-projet

Créez un nouveau projet Django appelé todo_app.

## Créer un nouveau projet Django
django-admin startproject todo_app
cd todo_app

2. Création d'une application

Ajoutez une nouvelle application pour gérer les tâches.

## Ajouter une nouvelle application
python manage.py startapp tasks

3. Configuration du modèle de données

Créez un modèle pour les tâches dans tasks/models.py.

## tasks/models.py
from django.db import models

class Task(models.Model):
    title = models.CharField(max_length=200)
    description = models.TextField()
    completed = models.BooleanField(default=False)

    def __str__(self):
        return self.title

4. Migration des modèles

Mettez à jour la base de données.

## Créer les migrations et appliquer les migrations
python manage.py makemigrations tasks
python manage.py migrate

5. Configuration des vues et URL

Ajoutez des vues pour afficher, ajouter et modifier les tâches dans tasks/views.py et todo_app/urls.py.

## tasks/views.py
from django.shortcuts import render, redirect, get_object_or_404
from .models import Task
from .forms import TaskForm

def task_list(request):
    tasks = Task.objects.all()
    return render(request, 'tasks/task_list.html', {'tasks': tasks})

def task_create(request):
    if request.method == 'POST':
        form = TaskForm(request.POST)
        if form.is_valid():
            form.save()
            return redirect('task_list')
    else:
        form = TaskForm()
    return render(request, 'tasks/task_form.html', {'form': form})

def task_update(request, pk):
    task = get_object_or_404(Task, pk=pk)
    if request.method == 'POST':
        form = TaskForm(request.POST, instance=task)
        if form.is_valid():
            form.save()
            return redirect('task_list')
    else:
        form = TaskForm(instance=task)
    return render(request, 'tasks/task_form.html', {'form': form})

def task_delete(request, pk):
    task = get_object_or_404(Task, pk=pk)
    if request.method == 'POST':
        task.delete()
        return redirect('task_list')
    return render(request, 'tasks/task_confirm_delete.html', {'task': task})
python
## todo_app/urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('', views.task_list, name='task_list'),
    path('new/', views.task_create, name='task_new'),
    path('<int:pk>/edit/', views.task_update, name='task_edit'),
    path('<int:pk>/delete/', views.task_delete, name='task_delete'),
]

6. Configuration des formulaires

Créez un formulaire pour les tâches dans tasks/forms.py.

## tasks/forms.py
from django import forms
from .models import Task

class TaskForm(forms.ModelForm):
    class Meta:
        model = Task
        fields = ['title', 'description', 'completed']

7. Configuration des templates

Créez les templates HTML pour afficher, ajouter et modifier les tâches dans tasks/templates/tasks/.

<!-- tasks/templates/tasks/task_list.html -->
<h1>Tâches</h1>
<ul>
    {% for task in tasks %}
        <li>
            task.title
            <a href="{% url 'task_edit' pk=task.pk %}">Modifier</a> |
            <a href="{% url 'task_delete' pk=task.pk %}">Supprimer</a>
        </li>
    {% endfor %}
</ul>
<a href="{% url 'task_new' %}">Ajouter une tâche</a>
html
<!-- tasks/templates/tasks/task_form.html -->
<h1>{% if task.id %}Modifier{% else %}Ajouter{% endif %} Tâche</h1>
<form method="post">
    {% csrf_token %}
    form.as_p
    <button type="submit">Enregistrer</button>
</form>
html
<!-- tasks/templates/tasks/task_confirm_delete.html -->
<h1>Supprimer Tâche</h1>
<p>Voulez-vous vraiment supprimer la tâche "task.title" ?</p>
<form method="post">
    {% csrf_token %}
    <button type="submit">Supprimer</button>
</form>

8. Configuration des URLs globales

Ajoutez les URL de l'application tasks dans todo_app/urls.py.

## todo_app/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('tasks.urls')),
]

9. Configuration du fichier settings.py

Assurez-vous que les configurations suivantes sont présentes dans le fichier todo_app/settings.py.

## todo_app/settings.py

INSTALLED_APPS = [
    ...
    'tasks',
]

TEMPLATES = [
    {
        ...
        'DIRS': [os.path.join(BASE_DIR, 'templates')],
        ...
    },
]

STATIC_URL = '/static/'

10. Déploiement sur Azure

Clonez le projet dans votre machine virtuelle Azure et exécutez les commandes suivantes.

## Cloner le projet
git clone https://github.com/your_username/todo_app.git
cd todo_app

## Créer un environnement virtuel et installer les dépendances
python3 -m venv myenv
source myenv/bin/activate
pip install django psycopg2-binary gunicorn

## Migrer la base de données
python manage.py migrate

## Collecter les fichiers statiques
python manage.py collectstatic

## Lancer Gunicorn
gunicorn todo_app.wsgi:application --bind 0.0.0.0:8000

Erreurs frequentes et debugging

1. ImportError: No module named 'psycopg2'

Message d'erreur :

ModuleNotFoundError: No module named 'psycopg2'

Correction :

Assurez-vous que psycopg2 est installé dans votre environnement virtuel.

pip install psycopg2-binary

2. OperationalError: could not connect to server: Connection refused

Message d'erreur :

django.db.utils.OperationalError: could not connect to server: Connection refused

Correction :

Assurez-vous que le service PostgreSQL est en cours d'exécution sur votre machine virtuelle.

sudo systemctl start postgresql

3. ModuleNotFoundError: No module named 'gunicorn'

Message d'erreur :

ModuleNotFoundError: No module named 'gunicorn'

Correction :

Assurez-vous que gunicorn est installé dans votre environnement virtuel.

pip install gunicorn

Pour aller plus loin

1. Intégration avec Azure DevOps

Utilisez Azure DevOps pour automatiser le déploiement et la maintenance de votre application Django.

En savoir plus

2. Utilisation d'un base de données Azure SQL

Utilisez un service de base de données relationnelle Azure pour stocker les données de votre application.

En savoir plus

3. Ajout d'authentification et de sécurité

Ajoutez une authentification et des fonctionnalités de sécurité supplémentaires à votre application Django.

En savoir plus

Défi pratique

Développez un mini-projet complet en utilisant Django sur Azure. Créez une API RESTful pour gérer les articles d'un blog, avec des fonctionnalités telles que la création, la lecture, la mise à jour et la suppression d'articles.

Consignes :

• Utilisez PostgreSQL comme base de données.
• Implémentez des vues pour chaque fonctionnalité (liste des articles, détail d'un article, création/modification/suppression).
• Créez un formulaire pour ajouter et modifier les articles.
• Configurez Nginx et Gunicorn pour servir votre application.

Dépôt Git : https://github.com/your_username/blog_api

Bonne chance avec votre mini-projet !