Introduction

En tant qu'ingénieurs back-end, nous sommes souvent chargés de créer des systèmes capables de faire évoluer et de gérer de nombreuses ressources, utilisateurs et entités, chacun nécessitant une identification unique. Dans de nombreux cas, l'utilisation d'ID séquentiels (par exemple, 1, 2, 3) semble être une solution simple, mais cela peut rapidement devenir problématique à mesure que votre application se développe et évolue sur des systèmes distribués. C'est là qu'interviennent les UUID (Universally Unique Identifiers).

Dans cet article de blog, nous explorerons :

• Qu'est-ce qu'un UUID
• Cas d'utilisation réels des UUID
• Comment implémenter les UUID en Python
• Risques liés à l'ignorance des UUID
• Erreurs courantes lors de l'utilisation des UUID
• Bonnes pratiques d'utilisation des UUID

Qu'est-ce qu'un UUID ?

Un UUID (Universally Unique Identifier) ​​est un nombre de 128 bits utilisé pour identifier de manière unique des informations dans les systèmes informatiques. Il est conçu pour être unique au monde, ce qui signifie que les UUID générés indépendamment dans différents systèmes n'entreront pas en conflit.

Un UUID ressemble à ceci :

66e69275-c6bc-800c-90a6-2f41cb991502

Il se compose de 32 chiffres hexadécimaux, affichés en cinq groupes séparés par des traits d'union, sous la forme 8-4-4-4-12.

Cas d'utilisation réels des UUID

1. Clés de base de données dans les systèmes distribués : dans les systèmes où différentes bases de données ou microservices doivent générer des identifiants uniques sans communiquer entre eux, les UUID garantissent l'unicité. Par exemple, dans une plateforme de commerce électronique distribuée, chaque service peut générer indépendamment des identifiants de commande ou de transaction, et les UUID éviteront toute collision.

2. ID de session : les UUID sont couramment utilisés pour identifier les sessions utilisateur dans les applications Web. Ils sont particulièrement utiles lorsque vous devez conserver les informations de session sans divulguer de données sensibles ou prévisibles.

3. Identificateurs de fichiers ou de ressources : lorsque vous devez suivre des fichiers, des documents ou toute ressource sur diverses plates-formes ou bases de données, un UUID peut être attribué à chaque ressource pour une recherche facile sans risque de doublons.

4. API et références externes : l'exposition d'identifiants séquentiels ou facilement devinables (par exemple, utilisateur/1, utilisateur/2) dans une API peut entraîner des vulnérabilités en matière de confidentialité. En utilisant des UUID (par exemple, user/66e69275-c6bc-800c-90a6-2f41cb991502), vous réduisez la probabilité que les utilisateurs devinent et accèdent à des ressources qui ne leur appartiennent pas.

Implémentation des UUID en Python

La bibliothèque uuid de Python simplifie la génération et la gestion des UUID. Voici comment :

import uuid

# Generate a UUID
generated_uuid = uuid.uuid4()
print(f"Generated UUID: {generated_uuid}")

La fonction uuid4() génère un UUID aléatoire basé sur des nombres aléatoires ou pseudo-aléatoires, qui est la variante la plus couramment utilisée dans le développement Web.

Exemple : utilisation des UUID comme clés primaires dans les bases de données

Lors de l'utilisation de bases de données comme PostgreSQL, il est courant d'utiliser les UUID comme clés primaires. Voici comment le configurer en Python avec SQLAlchemy :

from sqlalchemy import Column, String
from sqlalchemy.dialects.postgresql import UUID
import uuid
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class User(Base):
    __tablename__ = 'users'

    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4, unique=True, nullable=False)
    username = Column(String, nullable=False)

# This will generate a UUID primary key for each new user.

Dans cet exemple, nous définissons le champ id comme un UUID, garantissant que chaque utilisateur disposera d'un identifiant unique qui n'entrera pas en conflit avec d'autres enregistrements, même dans des bases de données distribuées.

Risques liés à l'ignorance des UUID

Ignorer les UUID au profit d'ID séquentiels ou à incrémentation automatique peut présenter plusieurs risques :

1. Vulnérabilités de sécurité : les identifiants séquentiels sont prévisibles, ce qui permet aux attaquants d'énumérer facilement les enregistrements et de découvrir des données sensibles. Par exemple, si les ID utilisateur sont séquentiels, un attaquant pourrait tenter de deviner d’autres ID utilisateur et accéder à des comptes non autorisés.

2. Collision de données : dans un système distribué, le recours à des entiers à incrémentation automatique peut entraîner des collisions d'ID, en particulier lorsque plusieurs services ou bases de données génèrent des ID sans coordination centrale.

3. Problèmes de migration et de fusion de données : lors de la combinaison de bases de données ou de la migration de données entre systèmes, le fait d'avoir des ID séquentiels non uniques peut provoquer des conflits. Les UUID évitent ces problèmes en garantissant l'unicité.

Erreurs courantes lors de l'utilisation des UUID

1. Stockage des UUID sous forme de chaînes : une erreur courante consiste à stocker les UUID sous forme de chaînes, ce qui gaspille de l'espace et peut ralentir les requêtes, en particulier dans les grandes bases de données. La plupart des bases de données modernes, comme PostgreSQL, ont des types d'UUID natifs qui stockent efficacement les UUID.

   Faux:
   

   CREATE TABLE users (
       id VARCHAR(36) PRIMARY KEY
   );
   

   Droite:
   

   CREATE TABLE users (
       id UUID PRIMARY KEY
   );
   

2. Ne pas utiliser la bonne version d'UUID : Il existe plusieurs versions d'UUID (par exemple, uuid1(), uuid3(), uuid4(), uuid5()), chacune adaptée à un usage spécifique. cas. uuid4(), basé sur des nombres aléatoires, est le plus couramment utilisé pour générer des identifiants uniques dans les applications Web. Faites attention à la version que vous utilisez et si elle correspond à vos besoins.

3. Ignorer les possibilités de collision : bien que les UUID soient conçus pour être uniques, il existe un très faible risque de collision. Pour la plupart des applications, le risque est négligeable, mais si vous générez des milliards d'UUID ou si vous travaillez dans des environnements très sensibles, vous devez mettre en œuvre la détection des collisions.

Meilleures pratiques d'utilisation des UUID

1. Utiliser les UUID pour les références externes : lorsque vous exposez des ID dans des URL ou des API, préférez les UUID aux ID séquentiels. Cela améliore la sécurité et rend plus difficile pour les utilisateurs de prédire les ID de ressources.

2. Stocker les UUID dans des formats natifs : utilisez le type d'UUID natif de la base de données pour stocker les UUID au lieu de chaînes. Cela réduit l'espace de stockage et améliore les performances des requêtes.

3. Choisissez la bonne version d'UUID : dans la plupart des cas, uuid4() (UUID aléatoire) est le meilleur choix pour générer des identifiants uniques dans les applications Web. Cependant, si vous avez besoin d'UUID générés de manière déterministe, vous pouvez envisager uuid3() ou uuid5() (UUID basés sur un espace de noms).

4. Valider les UUID : lorsque vous acceptez les UUID provenant d'une entrée utilisateur, validez-les toujours pour vous assurer qu'ils sont correctement formatés avant le traitement. En Python, vous pouvez utiliser des objets UUID pour vérifier la validité d'une chaîne.
   

def is_valid_uuid(uuid_to_test, version=4):
    try:
        uuid_obj = uuid.UUID(uuid_to_test, version=version)
        return str(uuid_obj) == uuid_to_test
    except ValueError:
        return False

# Example usage
print(is_valid_uuid("66e69275-c6bc-800c-90a6-2f41cb991502"))  # True
print(is_valid_uuid("invalid-uuid-string"))  # False

Conclusion

Les UUID sont des outils puissants pour générer des identifiants uniques dans les systèmes distribués et assurer la sécurité des applications Web. Ils vous aident à éviter des problèmes tels que les collisions de données, les attaques d'ID prévisibles et les conflits d'ID lors des migrations de bases de données. En comprenant et en suivant les meilleures pratiques en matière d'UUID, vous pouvez créer des systèmes backend plus robustes, évolutifs et sécurisés.

N'oubliez pas d'utiliser la version UUID appropriée, de les stocker correctement dans vos bases de données et d'être conscient de leurs risques potentiels. Grâce à ces conseils, vous serez bien équipé pour gérer efficacement les UUID dans vos projets !

N'hésitez pas à commenter ci-dessous si vous avez des questions ou des conseils supplémentaires sur les UUID ! Bon codage !