Comprendre les UUID : guide de l'ingénieur backend pour les développeurs juniors

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 d'ignorer les 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 tirets, 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. Identifiants 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 vous pouvez 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'identifiants séquentiels ou à incrémentation automatique peut présenter plusieurs risques :

1. Fulné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 identifiants utilisateur sont séquentiels, un attaquant pourrait tenter de deviner d'autres identifiants 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. Not Using the Correct UUID Version: There are several versions of UUIDs (e.g., uuid1(), uuid3(), uuid4(), uuid5()), each suited to specific use cases. uuid4(), based on random numbers, is the most commonly used for generating unique IDs in web applications. Be mindful of which version you’re using and whether it fits your needs.

3. Ignoring Collision Possibilities: While UUIDs are designed to be unique, there’s a very small chance of collision. For most applications, the risk is negligible, but if you’re generating billions of UUIDs or operating in highly sensitive environments, you should implement collision detection.

Best Practices for Using UUIDs

1. Use UUIDs for External References: When exposing IDs in URLs or APIs, prefer UUIDs to sequential IDs. This enhances security and makes it harder for users to predict resource IDs.

2. Store UUIDs in Native Formats: Use the database's native UUID type to store UUIDs instead of strings. This reduces storage space and improves query performance.

3. Choose the Right UUID Version: In most cases, uuid4() (random-based UUID) is the best choice for generating unique identifiers in web applications. However, if you need deterministically generated UUIDs, you might consider uuid3() or uuid5() (namespace-based UUIDs).

4. Validate UUIDs: When accepting UUIDs from user input, always validate them to ensure they are properly formatted before processing. In Python, you can use UUID objects to check the validity of a string.
   

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

UUIDs are powerful tools for generating unique identifiers in distributed systems and ensuring security in web applications. They help you avoid issues like data collisions, predictable ID attacks, and ID conflicts during database migrations. By understanding and following best practices for UUIDs, you can build more robust, scalable, and secure backend systems.

Remember to use the appropriate UUID version, store them correctly in your databases, and be mindful of their potential risks. With these tips, you’ll be well-equipped to handle UUIDs effectively in your projects!

---

Feel free to comment below if you have any questions or additional tips about UUIDs! Happy coding!

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!