Formation Elixir et Phoenix pour développeurs Rails

Description

Cette formation Phoenix pour développeurs Rails vous permettra de transposer votre expertise Ruby vers l'écosystème Elixir/Phoenix en reconstruisant une application existante, fonctionnalité par fonctionnalité.

Pendant 2 jours, vous apprendrez à :

• maîtriser Elixir et Phoenix en capitalisant sur vos réflexes Rails, sans repartir de zéro,
• concevoir des applications qui encaissent la 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.

Public

Cette formation s'adresse aux développeur·euse·s Ruby on Rails 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 différences entre Ruby MRI et la machine virtuelle BEAM
• Développer une application CRUD complète avec Phoenix et Ecto
• Comparer les composants Rails et Phoenix à chaque étape du développement
• Exploiter les mécanismes natifs d'OTP (processus, supervision, tolérance aux pannes)
• Déployer une application Phoenix et PostgreSQL avec Docker Compose
• Mettre en place un premier niveau d'observabilité

Pré-requis

• Bonne maîtrise de Ruby on Rails 7 ou 8 (MVC, ActiveRecord, migrations, tests)
• Notions de PostgreSQL et de SQL
• Connaissance de base de Docker
• Connaissance de base de Git
• Ordinateur portable à apporter

Le programme de la formation Elixir et Phoenix pour développeurs Rails

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

• Application Rails de référence
  • Modèles, contrôleurs, vues, routes, ActiveRecord, assets
  • Fonctionnalités à reproduire dans Phoenix
• De MRI à la BEAM : pourquoi Elixir ?
  • Historique : Erlang, OTP, BEAM, Elixir, Phoenix
  • Positionnement par rapport à Rails
  • Comparaison des modèles d'exécution : interprété vs compilé, GIL vs millions de processus, threads vs processus légers, exceptions vs supervision, objet vs fonctionnel
  • Immutabilité, pattern matching, message passing
• Les fondamentaux d'OTP
  • Process, GenServer, Supervisor, Application, Registry
  • Différences avec l'écosystème Rails : pas de Sidekiq obligatoire, supervision native, tolérance aux pannes
• Architecture Phoenix
  • Correspondance Rails ↔ Phoenix : ActiveRecord/Ecto, View/Component, ActionCable/Channels, Turbo/LiveView, Rack/Plug
  • Router, Endpoint, Plug, Controller, templates, components, LiveView
  • Installation d'Elixir, Erlang, Phoenix et PostgreSQL
  • Création du projet avec mix phx.new et découverte de la structure générée
• Reconstruction du CRUD avec Ecto
  • Repo, schemas, migrations et comparaison avec ActiveRecord
  • Génération avec mix phx.gen.html et analyse du code produit
  • Implémentation des entités métier : produits, catégories, clients, commandes
  • Changesets, validations et contraintes SQL
  • Router, layouts, composants 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
• Reconstruire le modèle de données de l'application Rails avec Ecto
• Traduire les validations ActiveRecord en changesets Ecto

Jour 2 — Fonctionnalités avancées et mise en production

• Phoenix LiveView
  • Pourquoi LiveView ? Comparaison avec Turbo, Stimulus et ActionCable
  • Liste dynamique, formulaire interactif, recherche instantanée
  • Phoenix Channels : communication temps réel bas niveau
• Composants et middleware
  • HEEx, Function Components, Layouts, Slots
  • Plug : authentification, autorisation, CORS, rate limiting (optionnel)
  • Comparaison avec les middleware Rack
• Observabilité
  • Telemetry, instrumentation, métriques, logs
• Build de production et conteneurisation
  • Configuration MIX_ENV=prod, compilation des assets, release OTP
  • Dockerfile multi-stage : image minimale, utilisateur non privilégié, optimisation de la taille
• Déploiement avec Docker Compose
  • Services Phoenix, PostgreSQL et Nginx en reverse proxy
  • Réseaux, volumes, secrets et variables d'environnement
  • Exécution automatique des migrations et gestion des releases
• Supervision et validation du déploiement
  • Phoenix LiveDashboard : processus, mémoire, requêtes HTTP et Ecto, métriques
  • Ajout de métriques Telemetry
  • Vérification complète de la stack déployée

Mises en pratique :

• Développer une fonctionnalité de recherche instantanée 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 1906 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 : 272 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