Formation Elixir & Phoenix pour développeurs Django

Description

Cette formation Phoenix pour développeurs Django vous permettra de transposer votre expertise Python vers l'écosystème Elixir/Phoenix en réimplémentant une application concrète.

Pendant 2 jours, vous apprendrez à :

• maîtriser Elixir et Phoenix en capitalisant sur votre expérience Django, sans repartir de zéro,
• concevoir des applications capables d'encaisser la montée en charge grâce à la concurrence native et à la supervision d'OTP,
• déployer en production une application Phoenix complète avec Docker Compose et PostgreSQL, prête à être exploitée en conditions réelles.

Vous repartez avec un guide de correspondance Django → Phoenix et une application Phoenix développée en formation.

Public

Cette formation s'adresse aux développeur·euse·s Django/Python expérimenté·e·s souhaitant transposer leur expertise vers l'écosystème Elixir/Phoenix.

Formation IA-friendly

Cette formation étant IA friendly, les sessions sont adaptées aux développeur·se·s qui souhaitent utiliser de l'IA pour coder. Les exercices sont conçus pour tirer parti des IDEs agentiques. Le·a formateur·rice vous accompagnera sur les bonnes pratiques du développement assisté par IA.

Les objectifs

• Comprendre les spécificités d'Elixir et de la BEAM par rapport à Python
• Développer une application Phoenix/Ecto
• Comparer les concepts Django et Phoenix à chaque étape
• Exploiter les mécanismes OTP (processus, supervision)
• Réaliser un déploiement complet avec Docker Compose et PostgreSQL
• Mettre en place une première chaîne d'observabilité

Pré-requis

• Expérience professionnelle du développement web avec Python et Django
• Être à l'aise avec les bases de données relationnelles et SQL
• Connaissance de base de Git
• Aucune connaissance préalable d'Elixir ou de la programmation fonctionnelle n'est nécessaire
• Ordinateur portable à apporter

Le programme de la formation Elixir & Phoenix pour développeurs Django

Jour 1 — Découverte de Phoenix et développement du cœur applicatif

• Application Django de référence
  • Modèles, vues, URLs, templates, ORM, administration
  • Fonctionnalités à reproduire dans Phoenix
• Introduction à Elixir et à l'écosystème OTP
  • Historique : Erlang, OTP, Elixir, Phoenix
  • Pourquoi Elixir pour le développement web
  • Comparaison des modèles d'exécution : GIL vs processus légers, threads/asyncio vs concurrence native, exceptions vs supervision, objet vs fonctionnel
  • Immutabilité, pattern matching, pipes, fonctions pures
  • Processus, GenServer, Supervisor, Application, Registry
  • Comparaison avec l'écosystème Python : Celery, Gunicorn/Uvicorn, multiprocessing, asyncio
• Architecture Phoenix
  • Comparaison Django ↔ Phoenix : Router, Controller/LiveView, Ecto, Plug, HEEx, Channels
  • Installation d'Elixir, Erlang, Phoenix, PostgreSQL
  • Création du projet avec mix phx.new et découverte de la structure générée
  • Configuration PostgreSQL et premier lancement
• Développement du CRUD avec Ecto
  • Repo, Schemas, Migrations, Queries
  • Génération avec mix phx.gen.html et analyse du code généré
  • Implémentation des entités métier : produits, catégories, clients, commandes
  • Changesets, contraintes et validations
  • Layouts, Components et navigation en HEEx

Mises en pratique :

• Créer un projet Phoenix et le connecter à PostgreSQL
• Générer un CRUD complet avec mix phx.gen.html et en analyser le code
• Réimplémenter le modèle de données de l'application Django avec Ecto
• Mettre en place les validations métier via les changesets

Jour 2 — Fonctionnalités avancées et déploiement

• Phoenix LiveView et Channels
  • Pourquoi LiveView ? Comparaison avec Django + HTMX/AJAX/WebSockets/Django Channels
  • Recherche dynamique, formulaire interactif, mise à jour temps réel
  • Phoenix Channels : communication temps réel bas niveau
• Components et middleware
  • Function Components, Slots, réutilisation
  • Plug : authentification, autorisation, sessions, CORS, rate limiting (optionnel)
  • Comparaison avec les middleware Django
• Observabilité et tests
  • Telemetry, logs, instrumentation
  • Introduction à OpenTelemetry
  • Tests, selon le temps disponible : ExUnit, ConnCase, LiveViewTest, en comparaison avec unittest/pytest et Django
• Build et conteneurisation
  • Compilation des assets, release OTP, configuration des variables d'environnement
  • Dockerfile multi-stage : image minimale, utilisateur non privilégié, optimisation de la taille
  • Docker Compose : application Phoenix, PostgreSQL, Nginx (réseaux, volumes, secrets, variables d'environnement)
• Déploiement et supervision
  • Exécution automatique des migrations et gestion des releases
  • Phoenix LiveDashboard : processus, mémoire, requêtes HTTP/SQL, métriques, supervision
  • Ajout de métriques Telemetry
  • Validation complète du déploiement et reprise après incident

Mises en pratique :

• Développer une fonctionnalité de recherche dynamique en LiveView
• Ajouter un middleware d'authentification avec Plug
• Construire une image Docker de production multi-stage en suivant les bonnes pratiques de sécurité
• Déployer la stack complète avec Docker Compose et valider via LiveDashboard

Télécharger le programme

Formateur

Jean PARPAILLON

Jean Parpaillon est ingénieur logiciel depuis 2004. Développeur puis CTO, il a construit son expertise au cœur de contextes exigeants : innovation technologique, startups, laboratoires de recherche et environnements à forte contrainte industrielle. Depuis 2018, il exerce comme consultant indépendant et s’est volontairement spécialisé sur une niche pointue : Elixir, qu’il utilise pour concevoir des systèmes distribués robustes, performants et maintenables.

Son parcours est profondément marqué par le DevOps et l’industrialisation des systèmes. Jean a piloté le déploiement d’outils d’automatisation, de CI/CD et d’infrastructures complexes, avec une approche très pragmatique : comprendre les besoins réels des équipes, sécuriser la production et rendre les architectures réellement exploitables dans la durée.

Cette vision se prolonge dans son engagement open source : il a présidé le consortium OW2 de 2017 à 2023, où il a travaillé sur des méthodologies d’industrialisation de projets Open Source, en réunissant des PME, des laboratoires, des universités et des grands groupes.

Depuis 2024, Jean transmet son expertise en formation. Son approche pédagogique alterne théorie claire, mise en pratique immédiate et fil rouge final permettant d’intégrer l’ensemble des technologies abordées : Ansible, Docker, Terraform, Git, Bash, Kubernetes, mais aussi Elixir et l’embarqué avec Buildroot. Ses formations s’adressent aux équipes qui veulent comprendre en profondeur ce qu’elles déploient… et pourquoi !

FAQ

8 raisons de participer à une formation Human Coders

• Satisfaction client élevée : Un taux de statisfaction de 4,6/5 depuis 2012 (sur 1902 sessions réalisées). 99% des participants se disent satisfaits de nos formations
• Approche pédagogique unique : Des formations en petit groupe, des formateurs passionnés et expérimentés, de véritables workshops... (Plus d'infos sur notre manifeste)
• Catalogue de formations complet : 263 formations au catalogue, de quoi vous accompagner sur tout vos projets
• Écosystème dynamique : Nous accompagnons les dev depuis 14 ans avec des initiatives comme Human Coders News, les Human Talks, le podcast ou encore notre serveur Discord
• Financement facilité : Organisme certifié Qualiopi, indispensable pour que vous puissiez obtenir des aides au financement via votre OPCO
• Références clients prestigieuses : De nombreux clients qui nous font confiance depuis des années
• Accompagnement sur mesure : Nous vous proposons un accompagnement personnalisé par nos consultants pour vous aider dans vos projets au-delà de la formation
• Valorisation professionnelle : Remise d'un diplôme, d'une attestation et d'une certification, suivant les formations effectuées, que vous pourrez afficher sur vos CV et réseaux sociaux