Symfony Web

Se connecter pour s'inscrire

Votre progression

Continuez pour débloquer la suite !
0 / 0 étapes complétées 0
%

Syllabus

  1. Description

  2. Objectifs

  3. Validations de compétences

  4. Public cible

    Aucun public cible spécifié pour ce module.

  5. Besoins techniques

  6. Prérequis

    • Aucun prérequis

  7. Niveau

  8. Historique du module

    Aucune action enregistrée

  1. Informations Générales

    1. public

      • Étudiants en Bachelor CDA 3ème année

    2. prérequis

      • Connaissances de base en PHP et en programmation orientée objet
      • Maîtrise des concepts web (HTML, CSS, JavaScript)
      • Notions de base sur les bases de données et SQL

    3. objectifs

      • Comprendre les fondamentaux du framework Symfony
      • Maîtriser la structure MVC (Modèle-Vue-Contrôleur)
      • Apprendre à configurer un environnement de développement Symfony
      • Créer des applications web dynamiques et sécurisées
      • Utiliser Doctrine ORM pour la gestion des bases de données
      • Créer et valider des formulaires
      • Mettre en place un système d'authentification et d'autorisation
      • Développer des API RESTful
      • Déployer une application Symfony en production
      • Appliquer les bonnes pratiques de développement avec Symfony

    4. durée

      • ~ 40 heures

  2. Modules du Cours

    1. Introduction à Symfony et installation

      1. Présentation de Symfony
        1. Historique et avantages de Symfony
        2. Comparaison avec d'autres frameworks PHP
        3. Cas d'utilisation courants
      2. Installation de Symfony
        1. Prérequis : PHP, Composer, serveur web
        2. Utilisation de Symfony CLI
        3. Création d'un projet Symfony
      3. Structure d'un projet Symfony
        1. Dossiers et fichiers clés
        2. Architecture MVC (Modèle-Vue-Contrôleur)
      4. Exercice pratique : Création d'une page d'accueil simple avec Twig

    2. Les bases de Symfony (Routing, Contrôleurs et Vues)

      1. Le système de routage
        1. Définition des routes avec YAML ou annotations
        2. Paramètres de route et contraintes
      2. Les contrôleurs
        1. Création d'un contrôleur
        2. Méthodes d'action et réponse HTTP
        3. Passage de paramètres aux vues
      3. Les vues avec Twig
        1. Syntaxe de base de Twig
        2. Héritage de templates
        3. Inclusion de templates partiels
      4. Exercice pratique : Création d'un blog simple avec des pages statiques et dynamiques

    3. Gestion des données avec Doctrine ORM

      1. Introduction à Doctrine ORM
        1. Concepts de base : entités, repositories, requêtes
        2. Configuration de la base de données
      2. Les entités
        1. Création d'une entité
        2. Propriétés, annotations et relations (OneToMany, ManyToOne, etc.)
      3. Les migrations
        1. Création et exécution des migrations
        2. Mise à jour du schéma de la base de données
      4. Exercice pratique : Ajout d'un système de gestion d'articles pour le blog

    4. Les formulaires et la validation

      1. Création de formulaires
        1. Utilisation du composant Form de Symfony
        2. Liaison d'un formulaire à une entité
      2. Validation des données
        1. Utilisation des contraintes de validation
        2. Messages d'erreur personnalisés
      3. Gestion des formulaires dans les contrôleurs
        1. Traitement des données soumises
        2. Redirection et messages flash
      4. Exercice pratique : Ajout d'un formulaire de création et d'édition d'articles

    5. Sécurité et authentification

      1. Introduction au composant Security
        1. Authentification et autorisation
        2. Rôles et hiérarchie des rôles
      2. Configuration de la sécurité
        1. Authentification par formulaire
        2. Protection des routes
      3. Gestion des utilisateurs
        1. Création d'une entité User
        2. Hashage des mots de passe
      4. Exercice pratique : Ajout d'un système de connexion/déconnexion au blog

    6. Les services et l'injection de dépendances

      1. Introduction aux services
        1. Définition et utilité
        2. Injection de dépendances
      2. Création de services personnalisés
        1. Déclaration d'un service
        2. Utilisation dans un contrôleur
      3. Exercice pratique : Création d'un service pour gérer les statistiques du blog

    7. API REST avec Symfony

      1. Introduction aux API REST
        1. Concepts de base : endpoints, méthodes HTTP, stateless
      2. Création d'une API
        1. Utilisation du composant Serializer
        2. Création de routes API
      3. Gestion des réponses
        1. Format JSON
        2. Codes de statut HTTP
      4. Exercice pratique : Création d'une API pour le blog

    8. Déploiement et bonnes pratiques

      1. Préparation au déploiement
        1. Optimisation de l'environnement de production
        2. Gestion des variables d'environnement
      2. Déploiement sur un serveur
        1. Utilisation de Docker ou d'un hébergement traditionnel
      3. Bonnes pratiques
        1. Organisation du code
        2. Sécurité et performances
      4. Exercice pratique : Déploiement du blog sur un serveur

    9. Projet final

      1. Objectif : Créer une application Symfony complète (ex : gestion de bibliothèque, réservation de salles, etc.)
      2. Évaluation : Présentation et soutenance du projet

  3. Ressources

    1. Documentation officielle de Symfony

Atelier guidé

Construire une fonctionnalité complète avec formulaire, validation, persistance, autorisation et test.

  1. Domaine : créer une entité, une migration et une contrainte qui protège une règle métier.
  2. Formulaire : lier un formulaire typé, afficher les erreurs et protéger la soumission avec CSRF.
  3. Sécurité et tests : ajouter une politique d’accès, écrire un test de succès et un test de refus.

Restitution de l’atelier

  • Une fonctionnalité Symfony avec migration.
  • Un formulaire validé et sécurisé.
  • Des tests fonctionnels et une commande de démonstration.
Validation : La fonctionnalité fonctionne depuis HTTP, refuse un accès interdit et conserve des données cohérentes après une erreur.

Exercices, examens et projets

Exercice

Atelier Symfony

Créer une entité, un contrôleur et une route.

Obligatoire Consulter
Examen

Examen Symfony

Évaluer architecture, formulaires, Doctrine et sécurité.

Obligatoire Consulter
Projet

Projet Symfony

Livrer une fonctionnalité complète avec tests.

Livrables :

  • Fonctionnalité
  • Tests
Obligatoire Consulter