Applications synchrones

Les applications monolithiques sont un type de logiciel dans lequel tous les composants du système (par exemple, l'interface utilisateur, la logique métier et la base de données) sont intégrés dans une structure unique et unifiée. Dans cette architecture, tous les composants s'exécutent dans le cadre d'une seule application.

---

Caractéristiques des applications monolithiques

• Structure unifiée :

  Tous les composants (frontend, backend et base de données) sont contenus dans un seul exécutable ou processus.

• Développement et déploiement simples :

  Les développeurs gèrent une base de code unique, ce qui simplifie le développement et le déploiement.

• Bonnes performances pour les projets à petite échelle :

  Convient aux projets de petite ou moyenne taille où la rapidité et la simplicité sont des priorités.

• Dépendance élevée des composants :

  Même de petits changements peuvent nécessiter la reconstruction et le redéploiement de l'intégralité de l'application.

---

Avantages des applications monolithiques

• Développement initial plus simple :

  Plus facile à démarrer pour les petits projets car il n'est pas nécessaire de mettre en œuvre des services séparés.

• Plus facile à gérer :

  Une base de code et un déploiement pour l'ensemble de l'application.

• Idéal pour les petites équipes :

  Convient aux équipes qui ne nécessitent pas de services de fractionnement.

• Hautes performances pour des requêtes simples :

  Aucune communication interservices signifie des temps de réponse plus rapides.

---

Inconvénients des applications monolithiques

1. Évolutivité difficile :

   Pour les grands projets, la mise à l'échelle ou la modification de parties du système nécessite souvent de réécrire des parties importantes du code.

2. Risque élevé de changements :

   De petits changements peuvent avoir un impact sur la fonctionnalité de l'ensemble du système.

3. Gestion complexe pour grandes équipes :

   Gérer une grande base de code devient un défi pour les grandes équipes de développement.

4. Longs délais de déploiement :

   À mesure que l'application se développe, les temps de compilation et de déploiement augmentent.

---

Quand utiliser des applications monolithiques ?

• Projets petits à moyens :

  Lorsque le projet est petit et ne nécessite pas une évolutivité étendue.

• Petites équipes de développement :

  Lorsque l'équipe est petite et que diviser les tâches créerait une complexité inutile.

• Durée limitée :

  Quand le projet doit être livré rapidement.

---

Créer une application monolithique avec Django

Django est conçu par défaut pour créer des applications monolithiques, ce qui facilite la création d'une application complète où toutes les parties, telles que la logique métier, la couche de présentation et la gestion de base de données, sont intégrées dans une structure unique.

---

Étapes pour créer une application monolithique dans Django

1. Créer un projet Django

Tout d'abord, créez un nouveau projet Django, qui met en place la structure globale de votre application.

django-admin startproject myproject
cd myproject

---

2. Créer des applications

Dans une architecture monolithique, chaque application est responsable d'une partie spécifique du projet, mais toutes les applications résident dans une base de code partagée et sont interconnectées.

python manage.py startapp blog
python manage.py startapp shop

• Application Blog : Gère les publications et les articles.
• Shop App : Gère les produits et les achats.

---

3. Paramètres initiaux dans settings.py

Ajoutez les applications nouvellement créées au fichier settings.py.

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'blog',
    'shop',
]

---

4. Définir des modèles

Chaque application définit des modèles liés à ses fonctionnalités. Ces modèles se connectent directement à la base de données.

Application de blog (models.py) :

from django.db import models

class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.title

Application boutique (models.py) :

from django.db import models

class Product(models.Model):
    name = models.CharField(max_length=100)
    price = models.DecimalField(max_digits=10, decimal_places=2)
    description = models.TextField()

    def __str__(self):
        return self.name

---

5. Gestion de base de données

Migrer les modèles vers la base de données :

python manage.py makemigrations
python manage.py migrate

---

6. Définir les URL

Définissez les itinéraires de vos applications dans le fichier urls.py du projet.

monprojet/urls.py :

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('blog/', include('blog.urls')),  # Blog App URL
    path('shop/', include('shop.urls')),  # Shop App URL
]

blog/urls.py :

from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='blog_index'),
]

shop/urls.py :

from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='shop_index'),
]

---

7. Créer des vues

Les vues gèrent les demandes et envoient des réponses.

Application de blog (views.py) :

from django.shortcuts import render
from .models import Post

def index(request):
    posts = Post.objects.all()
    return render(request, 'blog/index.html', {'posts': posts})

Application boutique (views.py) :

from django.shortcuts import render
from .models import Product

def index(request):
    products = Product.objects.all()
    return render(request, 'shop/index.html', {'products': products})

---

8. Créer des modèles

Définissez des modèles pour afficher les données dans vos applications.

Modèle de blog (blog/templates/blog/index.html) :

<h1>Blog Posts</h1>
<ul>
    {% for post in posts %}
        <li>{{ post.title }}</li>
    {% endfor %}
</ul>

Modèle de boutique (shop/templates/shop/index.html) :

<h1>Shop Products</h1>
<ul>
    {% for product in products %}
        <li>{{ product.name }} - ${{ product.price }}</li>
    {% endfor %}
</ul>

---

9. Exécutez le serveur et testez le projet

Exécutez le serveur Django et testez votre application :

django-admin startproject myproject
cd myproject

• Ouvrez http://127.0.0.1:8000/blog/ pour afficher les articles du blog.
• Ouvrez http://127.0.0.1:8000/shop/ pour voir les produits.

---

Avantages et inconvénients de cette approche dans Django

Avantages :

1. Simplicité dans le développement :Toutes les parties du projet sont dans une seule structure gérable.
2. Intégration complète :Tous les composants sont directement connectés sans la complexité de la communication interservices.

Inconvénients :

1. Évolutivité limitée :À mesure que le projet se développe, la gestion de la base de code devient plus difficile.
2. Risque élevé :Une erreur dans une partie peut avoir un impact sur l'ensemble du système.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!