Deployer Django sur Supabase

Pourquoi Deployer Django sur Supabase ?

Contexte réel : pourquoi un dev a besoin de ca au quotidien

Deploiement d'application web est une tâche cruciale qui demande une expertise en gestion de serveur, base de données et sécurité. C'est une étape complexe nécessitant des compétences techniques solides. Supabase offre une solution simplifiée pour le déploiement, en fournissant un environnement prêt à l'emploi avec des fonctionnalités robustes. Pour les développeurs Django, cela signifie pouvoir déployer rapidement et facilement leurs applications sans se soucier de la gestion du serveur.

Un cas d'utilisation concret en 2-3 phrases

Imaginez que vous développez une application web pour gérer un blog avec des fonctionnalités avancées comme l'authentification, les commentaires, les catégories et le partage social. En utilisant Supabase comme base de données et Django pour la logique métier, vous pouvez déployer votre application en quelques minutes. Cela vous permet d'avoir une application robuste et performante sans avoir à gérer la complexité de l'infrastructure sous-jacente.

Prerequis

• Connaissances nécessaires :

  • Familiarité avec Django et les concepts de base.
  • Connaissance des bases de données SQL (préférablement PostgreSQL).
  • Compréhension de la gestion du serveur et des déploiements web.
  • Connaissance de Git pour le contrôle de version.

• Outils à installer :

  • Python (3.8 ou plus récent)
  • pip (généralement installé avec Python)
  • virtualenv
  • Node.js et npm (pour les dépendances Frontend si nécessaire)

Concepts fondamentaux

Supabase : La plateforme d'IA pour la base de données

Supabase est une base de données PostgreSQL avec des fonctionnalités avancées tels que le stockage, les API RESTful et GraphQL, et l'intégration avec d'autres services. Il offre une interface web intuitive pour gérer les données et des outils puissants pour développer des applications.

## Installation de Supabase CLI (pour la gestion locale)
npm install -g supabase-cli

Django : Le framework web Python

Django est un framework web complet qui encourage le développement rapide et propre. Il prend en charge les fonctionnalités essentielles d'une application web telles que l'authentification, les formulaires, les modèles de données, les vues et les URL.

## Importations nécessaires dans Django
from django.contrib.auth.models import User
from django.db import models

class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    author = models.ForeignKey(User, on_delete=models.CASCADE)

Middleware : Le filtre entre les requêtes et les réponses

Django utilise le concept de middleware pour traiter les requêtes et les réponses avant qu'elles ne soient envoyées au client. Cela permet d'ajouter des fonctionnalités comme l'authentification, la gestion des exceptions et la modification des données.

## Exemple de middleware simple en Django
from django.utils.deprecation import MiddlewareMixin

class SimpleMiddleware(MiddlewareMixin):
    def process_request(self, request):
        print("Request received")
    
    def process_response(self, request, response):
        print("Response sent")
        return response

Templates : La représentation visuelle des données

Les templates en Django permettent de créer des pages HTML dynamiques en utilisant une syntaxe mixte de Python et de HTML. Ils sont particulièrement utiles pour afficher les données des modèles dans la base de données.

<!-- Exemple d'un template Django -->
{% extends 'base.html' %}

{% block content %}
    <h1>post.title</h1>
    <p>post.content</p>
{% endblock %}

Mise en pratique : projet fil rouge

Un mini-projet complet et réaliste : un gestionnaire de tâches

Pour ce tutoriel, nous allons créer un simple gestionnaire de tâches. L'application permettra aux utilisateurs de créer, lire, mettre à jour et supprimer des tâches.

Étape 1 : Création du projet Django

## Créer un environnement virtuel et activer-le
python -m venv venv
source venv/bin/activate

## Installer Django
pip install django

## Créer le nouveau projet Django
django-admin startproject todo_list
cd todo_list

Étape 2 : Création de l'application

## Créer une nouvelle application dans le projet
python manage.py startapp tasks

Étape 3 : Configuration des modèles

## models.py dans l'application 'tasks'
from django.db import models

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

    def __str__(self):
        return self.title

Étape 4 : Création des vues

## views.py dans l'application 'tasks'
from django.shortcuts import render, get_object_or_404, redirect
from .models import Task

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

def task_detail(request, pk):
    task = get_object_or_404(Task, pk=pk)
    return render(request, 'tasks/task_detail.html', {'task': task})

def task_new(request):
    if request.method == "POST":
        form = TaskForm(request.POST)
        if form.is_valid():
            task = form.save(commit=False)
            task.save()
            return redirect('task_detail', pk=task.pk)
    else:
        form = TaskForm()
    return render(request, 'tasks/task_edit.html', {'form': form})

def task_edit(request, pk):
    task = get_object_or_404(Task, pk=pk)
    if request.method == "POST":
        form = TaskForm(request.POST, instance=task)
        if form.is_valid():
            task = form.save(commit=False)
            task.save()
            return redirect('task_detail', pk=task.pk)
    else:
        form = TaskForm(instance=task)
    return render(request, 'tasks/task_edit.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})

Étape 5 : Configuration des URL

## urls.py dans l'application 'tasks'
from django.urls import path
from . import views

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

Étape 6 : Création des templates

<!-- task_list.html -->
{% extends 'base_generic.html' %}

{% block content %}
<h2>Tâches</h2>
<ul>
    {% for task in tasks %}
        <li><a href="{% url 'task_detail' pk=task.pk %}">task.title</a></li>
    {% endfor %}
</ul>
<a href="{% url 'task_new' %}">Nouvelle tâche</a>
{% endblock %}
html
<!-- task_detail.html -->
{% extends 'base_generic.html' %}

{% block content %}
<h2>task.title</h2>
<p>task.description</p>
<p>Complétée : task.completed</p>
<a href="{% url 'task_edit' pk=task.pk %}">Éditer</a>
<a href="{% url 'task_delete' pk=task.pk %}">Supprimer</a>
<a href="{% url 'task_list' %}">Retour à la liste des tâches</a>
{% endblock %}
html
<!-- task_edit.html -->
{% extends 'base_generic.html' %}

{% block content %}
<h2>{% if form.instance.pk %}Modifier{% else %}Nouvelle{% endif %} Tâche</h2>
<form method="post">
    {% csrf_token %}
    form.as_p
    <button type="submit">Enregistrer</button>
</form>
<a href="{% url 'task_list' %}">Retour à la liste des tâches</a>
{% endblock %}
html
<!-- task_confirm_delete.html -->
{% extends 'base_generic.html' %}

{% block content %}
<h2>Supprimer Tâche?</h2>
<p>Voulez-vous vraiment supprimer cette tâche ?</p>
<form method="post">
    {% csrf_token %}
    <button type="submit">Oui, supprimer</button>
</form>
<a href="{% url 'task_list' %}">Non, retourner à la liste des tâches</a>
{% endblock %}

Étape 7 : Configuration globale

## urls.py dans le projet 'todo_list'
from django.contrib import admin
from django.urls import path, include

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

Erreurs fréquentes et debugging

1. OperationalError: no such table

Cette erreur se produit lorsque Django ne trouve pas la table correspondant au modèle dans la base de données.

## Code incorrect
class Task(models.Model):
    title = models.CharField(max_length=200)
    description = models.TextField()
python
## Code correct
python manage.py makemigrations
python manage.py migrate

2. TemplateDoesNotExist

Cette erreur se produit lorsque Django ne trouve pas le template spécifié.

<!-- Code incorrect -->
{% extends 'base.html' %}

{% block content %}
<h1>post.title</h1>
<p>post.content</p>
{% endblock %}
python
## Code correct
## Assurez-vous que 'tasks/task_list.html' existe dans les templates

3. AttributeError: 'TaskForm' object has no attribute 'cleaned_data'

Cette erreur se produit lorsque vous essayez d'accéder à la méthode cleaned_data sur un formulaire non valide.

## Code incorrect
if form.is_valid():
    task = form.save(commit=False)
    task.save()
python
## Code correct
if form.is_valid():
    task = form.cleaned_data['title']
    # Utilisez cleaned_data pour accéder aux données validées
    task.save()
else:
    print(form.errors)

Pour aller plus loin

1. Intégration avec Supabase

Supabase offre une API RESTful et GraphQL, ce qui vous permet de connecter facilement votre application Django à Supabase pour la gestion des données.

## Exemple d'API POST avec requests (pour ajouter une tâche)
import requests

url = "https://your-supabase-url.supabase.co/rest/v1/tasks"
headers = {
    'apikey': 'your-api-key',
    'Authorization': 'Bearer your-anon-token'
}
payload = {
    'title': 'Nouvelle Tâche',
    'description': 'Description de la tâche'
}

response = requests.post(url, headers=headers, json=payload)
print(response.json())

2. Authentification avancée

Django offre des fonctionnalités d'authentification robustes qui peuvent être étendues pour répondre aux besoins spécifiques de votre application.

## Exemple d'un formulaire de connexion personnalisé
from django import forms
from django.contrib.auth.forms import AuthenticationForm

class LoginForm(AuthenticationForm):
    username = forms.CharField(widget=forms.TextInput(attrs={'autofocus': True}))
    password = forms.CharField(
        label='Password',
        strip=False,
        widget=forms.PasswordInput(attrs={'autocomplete': 'current-password'}),
    )

3. Déploiement sur Heroku

Heroku est une plateforme de déploiement cloud simple et rapide qui permet d'héberger votre application Django.

## Installation de Heroku CLI
curl https://cli-assets.heroku.com/install.sh | sh

## Connexion à Heroku
heroku login

## Création d'une nouvelle application Heroku
heroku create your-app-name

## Déploiement sur Heroku
git push heroku master

Défi pratique : Ajout de notifications push

Ajoutez une fonctionnalité qui envoie des notifications push lorsqu'une tâche est créée ou mise à jour. Utilisez un service comme Pusher pour cela.

## Exemple d'ajout de notifications avec Pusher
from django.dispatch import receiver
from django.db.models.signals import post_save
from .models import Task

@receiver(post_save, sender=Task)
def send_push_notification(sender, instance, created, **kwargs):
    if created:
        # Envoi d'une notification pour la création d'une tâche
        pass
    elif not instance.completed:
        # Envoi d'une notification pour la mise à jour d'une tâche
        pass

Ce tutoriel vous a montré comment déployer une application Django sur Supabase. En suivant ces étapes, vous aurez une compréhension approfondie des concepts fondamentaux et de la mise en pratique du développement web avec Django et Supabase. N'oubliez pas de tester votre application localement et de vérifier qu'elle fonctionne correctement avant le déploiement.