Développement back-end : missions et exercice pratique
Le développement back-end définit les traitements du serveur, la persistance des données et les conditions d’accès. Il traduit une règle métier en opérations dont les entrées, les effets et les erreurs sont explicites. Une interface qui affiche un succès ne suffit pas à établir que ces opérations ont abouti.
Ces fiches décrivent des activités et des exercices pédagogiques. Elles ne constituent ni des offres d’emploi, ni des parcours certifiants, ni des promesses de recrutement.
Développer la logique serveur, les échanges de données et les règles de l’application. Le back-end veille à ce qu’une action soit autorisée, validée et enregistrée de manière cohérente.
Activités courantes
Définir les modèles de données et les contrats d’API.
Contrôler les entrées, droits, doublons et erreurs de traitement.
Préparer les migrations, journaux utiles et procédures de reprise.
Responsabilités à préciser avec l’équipe
Une API fonctionnelle ne prouve pas le bon fonctionnement du parcours utilisateur. Le back-end partage avec le front-end la définition des états et avec l’exploitation les contraintes de déploiement et de restauration.
Un premier travail à montrer
Créer un service de démonstration qui teste entrée invalide, action non autorisée, double envoi et reprise après erreur.
Ce repère éditorial décrit des activités fréquentes. Les intitulés et périmètres varient selon les équipes ; il ne constitue pas un référentiel de certification.
Construire un service de demandes qui valide les entrées et conserve un statut de traitement.
Travaillez sur une copie ou un environnement de démonstration. Définissez les données utilisées et le résultat attendu avant de commencer. Conservez vos décisions et les difficultés rencontrées afin de pouvoir expliquer la démarche.
Décrire le contrat des entrées, des résultats et des erreurs.
Vérifier les droits à chaque opération et définir les données nécessaires.
Tester doublons, valeurs limites et dépendance temporairement indisponible.
Préparer migrations, sauvegarde et procédure de reprise.
Livrable et vérifications
Documentez les champs acceptés, les réponses et les statuts de traitement du service de demandes. Fournissez des cas de requête acceptée, refusée et répétée, les données créées et les moyens de retrouver un échec sans exposer le contenu privé de la demande.
Envoyez une demande incorrecte sans passer par le formulaire, puis essayez l’accès à une demande d’un autre compte. Vérifiez le refus côté serveur et l’absence d’effet indésirable. Rejouez aussi une requête répétée et une dépendance indisponible selon les règles annoncées.
Une validation dans le navigateur ne remplace pas le contrôle du serveur. Les messages et journaux doivent aider au diagnostic sans exposer d’information privée.
Collaboration à explorer : Développement front-end.
Exemple fictif de livrable : Le traitement vérifie les données reçues, applique les règles prévues et renvoie un résultat que l’interface peut expliquer.
Ce qui se transmet entre les rôles : Les champs, formats attendus et réponses possibles doivent être compris des deux côtés. Pour vérifier le parcours, il faut examiner l’erreur, la réussite et le traitement effectif de la demande, au-delà de l’apparence du bouton.
1 · BesoinEmpêcher qu’une demande répétée soit traitée deux fois.
2 · LivrableUne règle de traitement et des réponses documentées.
3 · ContrôleRejouer une requête et contrôler le résultat produit.
Ce que le résultat permet de conclure
Les cas d’erreur et de répétition doivent être définis avant de brancher le traitement à une action réelle.
Pour présenter ce travail, précisez le contexte, votre rôle, les éléments fournis par d’autres et la version examinée. Un exemple de démonstration doit être identifiable comme tel. La personne qui relit doit pouvoir retrouver le besoin, comprendre la décision et reproduire le contrôle sans deviner les étapes manquantes.
Ce qu’il faut joindre au livrable
Décrivez une requête valide, une requête refusée et une répétition du même envoi. Indiquez les données attendues, les contrôles effectués et les réponses retournées sans révéler d’identifiants ni de secrets.
Un exemple à examiner
Spécifier le traitement d’une demande répétée
Support pédagogique fictif : cet extrait illustre une partie d’un livrable. Il ne constitue ni une référence client, ni une spécification complète, ni une preuve de qualification professionnelle.
Extrait de livrable
Opération fictive : créer une demande de réservation.
Identifiant métier de la demande : demande-demo-17.
Premier traitement : création d’une seule demande.
Répétition du même envoi : retrouver le résultat prévu.
Même identifiant, contenu différent : cas à refuser ou à arbitrer.
Essai de concurrence : deux envois identiques arrivent avant la fin du premier traitement.
Attendu : une demande métier, un résultat retrouvable et aucune seconde création.
Ce que l’auteur doit pouvoir expliquer
L’effet d’une répétition est une règle à concevoir ; utiliser POST ne l’empêche pas à lui seul.
La portée et la durée de conservation de l’identifiant doivent être définies.
Les contrôles et la gestion de concurrence se vérifient sur le serveur.
Désactiver le bouton suffit-il à éviter les doublons ?
Cela peut limiter certains clics, mais un envoi peut être répété autrement. Il faut définir le comportement serveur, les contraintes de stockage et le résultat renvoyé. Ce texte décrit un contrat d’exemple, pas une implémentation complète. Rejouez aussi le même identifiant avec un contenu différent et conservez le résultat de refus prévu par le contrat fictif. Vérifiez le nombre d’objets créés, pas seulement les réponses HTTP. Un résultat perdu après écriture doit pouvoir être recherché sans déclencher une nouvelle création.
Référence technique : MDN · POST · . L’extrait est un exemple pédagogique original.
Évaluer la qualité du travail
Prenez une demande de modification d’un dossier fictif et examinez ce que le serveur accepte pour chaque compte de test. Les champs visibles ne définissent pas les droits réels. La validation des données et l’autorisation sur le dossier sont deux contrôles distincts, qui doivent rester effectifs lorsqu’une requête est envoyée directement à l’API.
Faites défiler le tableau horizontalement pour lire toutes les colonnes. Au clavier, placez le focus sur la zone du tableau puis utilisez les flèches.
Évaluer la qualité du travail
Compétence
Preuve à examiner
Erreur à repérer
Entrées et règles métier
Définir les champs admis, formats, bornes et transitions d’état. Prévoir une réponse pour champ inattendu, valeur absente et donnée devenue obsolète.
Le serveur réutilise une valeur fournie par le client comme si elle avait déjà été validée, ou accepte une transition impossible dans le parcours prévu.
Droits sur l’objet
Décrire les opérations autorisées pour chaque compte et vérifier le droit sur le dossier ciblé à chaque requête concernée. Utiliser des objets fictifs séparés.
Changer l’identifiant permet de consulter ou modifier le dossier d’un autre compte, alors que l’interface avait simplement masqué le lien.
Erreur
Le code HTTP, le message public et la journalisation ont un rôle clair.
La réponse expose une trace technique ou annonce un succès après un échec.
Opération répétée
Définir les validations côté serveur et le comportement de la même demande envoyée deux fois.
Un double clic ou une nouvelle tentative ne crée pas deux opérations métier ; le contrôle ne dépend pas seulement du bouton.
Une prochaine étape ciblée
Préparez deux comptes de test avec des dossiers distincts et rejouez la même modification avec chaque combinaison de compte et d’objet. Vérifiez refus, effet en base et message public sans exposer de secret. Un statut d’erreur ne suffit pas si l’opération a tout de même changé des données ; contrôlez aussi l’absence d’effet non autorisé.
Ouvrir la même version avec deux éditeurs, enregistrer le premier puis rejouer le second avec son ancien validateur. Comparer aussi les données réellement conservées.
Si une même URL produit des réponses différentes selon Accept-Language, Vary signale ce critère au cache. Garder une valeur cohérente dans les réponses 200 et 304. Des URL linguistiques distinctes ne nécessitent pas cet en-tête uniquement parce que le site est multilingue.
If-Match compare un validateur fort avant une écriture. Dans le contrat présenté, une version dépassée reçoit 412 ; le brouillon est conservé pour comparer les changements.
Les dates indiquent la consultation des références. Ces repères ne constituent ni un audit du site ni une déclaration globale de conformité.
Un cas de revue à reproduire
Une reprise crée deux opérations
Situation à examiner
Une requête acceptée est rejouée après un délai réseau. Le service crée une seconde opération alors que l’utilisateur n’avait demandé qu’une seule action.
Vérification proposée
Dans une copie, envoyez deux fois le même événement de test et observez les identifiants et les écritures. Définissez le comportement attendu des répétitions et des échecs partiels. Vérifiez la correction sans déclencher de messages ou paiements réels.
Preuve à conserver
Le journal de test relie événement, identifiant et résultat. Il démontre la règle de traitement retenue et les limites du scénario, sans exposer de données sensibles.
Exemple de constat fictif
Deux reprises portent la même référence d’opération DEMO-42. Le journal de démonstration montre deux réceptions et deux écritures alors qu’une seule opération était attendue.
Interpréter ce résultat
Définir et tester la règle de dédoublonnage. Deux réponses techniques réussies ne justifient pas deux opérations métier ; POST ne garantit pas à lui seul l’idempotence.
Trois essais complémentaires
Cas fictifs : adaptez ces attentes à votre contrat de test et conservez les limites du contrôle.
1Opération identifiée
2Écriture vérifiée
3Résultat retrouvable
Faites défiler le tableau horizontalement si nécessaire ; au clavier, placez le focus dessus puis utilisez les flèches.
Variations du scénario et preuves attendues
Variation à tester
Résultat attendu dans ce cas
Trace à transmettre
Deux envois identiques concurrents
Une seule opération selon ce contrat fictif
Identifiant métier et nombre d’écritures
Même clé, contenu différent
Refus ou arbitrage explicite sans seconde création
Clé, empreinte du contenu et réponse prévue
Réponse perdue après écriture
Retrouver le résultat sans recréer l’opération
Objet retrouvé et lien avec le premier envoi
Décision à transmettre : Vérifier effet métier et stockage ; le contrat doit définir portée, conservation et concurrence.
Exercice approfondi : préparez un endpoint de démonstration qui reçoit une demande et renvoie un état explicite. Utilisez des données fictives et un environnement local sans envoi réel. Testez un champ manquant, une valeur trop longue, un contenu inattendu et un double envoi. Validez les données côté serveur, même si le formulaire fournit déjà des contrôles. Distinguez l’acceptation technique de la demande de son traitement par une personne. Les journaux doivent aider au diagnostic sans exposer les informations saisies inutilement.
Éléments à remettre avec le travail
Contrat de données et exemples de requêtes
Validation serveur et réponses d’erreur
Tests des limites et des doubles envois
Instructions de configuration sans secrets
Critères de validation
Ces critères sont une base de travail à adapter au contexte. Pour chacun, notez l’action effectuée, le résultat attendu, le résultat observé et les informations restant à confirmer.
Une requête invalide ne produit pas d’effet partiel.
Les limites de taille et les formats sont contrôlés côté serveur.
Le double envoi a un comportement documenté et testé.
Les logs de démonstration ne contiennent aucun secret ni donnée personnelle réelle.
Livrez le contrat, les réponses possibles et les conditions de traitement avec le code. Décrivez les dépendances d’environnement sans recopier leurs identifiants. Une personne qui reprend le service doit pouvoir reproduire une erreur avec un jeu de données de test. Séparez les contrôles réalisés localement des vérifications qui dépendraient d’un service externe ; ne déclarez pas un envoi réel réussi lorsqu’il n’a pas été effectué.
Une opération doit rester explicable lorsqu’elle échoue ou se répète. Comparez un traitement immédiat et une tâche différée selon la durée, les dépendances et le résultat attendu.
Traitement dans la requête
Quand la retenir
Adapté à une opération courte dont la réussite peut être confirmée immédiatement. Définissez les validations, droits et erreurs avant d’écrire le résultat.
Ce qu’il faut prévoir
Contrôlez les répétitions et changements concurrents. Une réponse d’erreur ne doit pas laisser des données dans un état inexpliqué.
Traitement différé avec statut
Quand la retenir
Utile pour une importation longue ou un service extérieur. Retournez une référence permettant de retrouver l’état de la tâche.
Ce qu’il faut prévoir
Définissez les reprises, échecs définitifs et prévention des doublons. Distinguez une tâche reçue, en cours et réellement terminée.
Un risque à anticiper
Un succès partiel peut être présenté à tort comme une opération réussie. Documentez ce qui fait foi et les données nécessaires pour comprendre une interruption.
Comment décider
Rejouez une demande et provoquez une indisponibilité de dépendance. Le résultat final doit rester cohérent avec le statut annoncé et les traces de diagnostic.
Comparez règles de traitement, permissions, persistance et contrat de service. Une réponse de démonstration et une opération protégée avec cas d’erreur et reprise sont des livrables différents.
Exploitation récurrente
Précisez mises à jour, surveillance et contrôle des sauvegardes. Séparez exploitation et évolution fonctionnelle ; un serveur disponible ne prouve pas que les opérations métier aboutissent.
Sortie et transmission
Prévoyez code, schémas, migrations et procédure de restauration. Transmettez les accès par une méthode autorisée sans les publier dans les documents ; une copie de code ne sauvegarde pas la base.
Un bouton masqué suffit-il à protéger une opération ?
Non. Testez l’opération directement avec un compte fictif dépourvu du droit requis et un identifiant connu. Le serveur doit appliquer la règle indépendamment de l’interface. Conservez le statut et l’effet observé sans publier de jeton, de mot de passe ou de donnée réelle.
Comment montrer qu’un traitement supporte une répétition ?
Envoyez deux fois la même opération de test selon le contrat prévu. Vérifiez les données et les effets associés, comme les notifications, plutôt que le seul code de réponse. Décrivez la règle qui distingue répétition, nouvelle demande légitime et reprise après erreur.
Que contient une réponse d’erreur utile ?
Elle permet d’identifier l’opération, le problème et la prochaine action, sans exposer de données sensibles. Prévoyez un identifiant de corrélation si nécessaire. Distinguez une erreur corrigible par l’utilisateur d’un incident nécessitant une intervention technique.