Seminar Phoenix Framework – Grundlagen und erste Webanwendung

Das dreitägige Grundlagenseminar führt von der Entwicklungsumgebung zu einer vollständigen Phoenix-Webanwendung. Request Lifecycle, Router, Controller, HEEx, Ecto, Contexts, LiveView, Authentifizierung, Tests und ein erster Produktionsbuild werden in einem zusammenhängenden Projekt erarbeitet.

Inhaltsübersicht

• Seminarprofil, Zielgruppe und Voraussetzungen
• Lernziele
• Schrittweise Seminarinhalte
• Praxisprojekt
• Methodik

Zielgruppe

Elixir-Entwickler ohne Phoenix-Erfahrung, Webentwickler mit Erfahrung in anderen Frameworks und technische Quereinsteiger mit Programmierpraxis

Voraussetzungen

Grundkenntnisse in Elixir, funktionaler Programmierung, HTML und relationalen Datenbanken

Lernziele

• Phoenix-Projekte sicher erzeugen und strukturieren
• Klassische und interaktive Webfunktionen implementieren
• Datenzugriff über Ecto und Contexts organisieren
• Anwendung mit Tests und Produktionskonfiguration absichern

Seminarinhalte

1. Entwicklungsumgebung und Projektstart

1. Schritt 1: Elixir, Erlang, Datenbank und Phoenix-Werkzeuge prüfen.
2. Schritt 2: Eine neue Anwendung mit geeigneten Optionen erzeugen.
3. Schritt 3: Konfiguration, Verzeichnisstruktur und Entwicklungsserver einordnen.

2. Request Lifecycle

1. Schritt 1: Weg einer Anfrage vom Endpoint bis zur Antwort verfolgen.
2. Schritt 2: Plug-Pipeline, Router und Controller zusammensetzen.
3. Schritt 3: Verbindungsdaten und Assigns kontrolliert weiterreichen.

3. Routing und Controller

1. Schritt 1: Browser-Pipeline und Routen strukturieren.
2. Schritt 2: Parameter lesen, Context-Funktionen aufrufen und Antworten erzeugen.
3. Schritt 3: Redirects, Flash-Meldungen und Fehlerpfade behandeln.

4. HEEx und Komponenten

1. Schritt 1: Dynamisches HTML sicher mit HEEx rendern.
2. Schritt 2: Wiederkehrende UI-Teile als Funktionskomponenten erstellen.
3. Schritt 3: Attribute, Slots und Formularkomponenten einsetzen.

5. Ecto und Datenmodell

1. Schritt 1: Migrationen und Schemas für das Praxisprojekt erstellen.
2. Schritt 2: Changesets für Cast, Validierung und Fehlerausgabe nutzen.
3. Schritt 3: CRUD-Operationen und Associations über ein Repository ausführen.

6. Contexts und Generatoren

1. Schritt 1: Fachliche Funktionen in einem Context bündeln.
2. Schritt 2: Generatorausgaben lesen und gezielt anpassen.
3. Schritt 3: Webschicht, Context und Datenmodell sauber trennen.

7. LiveView-Einstieg

1. Schritt 1: LiveView-Routen und Lifecycle einrichten.
2. Schritt 2: Zustand über Assigns verwalten und Events behandeln.
3. Schritt 3: Formularvalidierung und Navigation ohne vollständigen Seitenwechsel umsetzen.

8. Authentifizierung und Scopes

1. Schritt 1: Generierte Authentifizierung in das Projekt integrieren.
2. Schritt 2: Aktuelle Identität und Scope an Context-Aufrufe übergeben.
3. Schritt 3: Geschützte Controller- und LiveView-Bereiche definieren.

9. Automatisierte Tests

1. Schritt 1: Context- und Datenbanktests mit Sandbox erstellen.
2. Schritt 2: Controller- und LiveView-Verhalten über öffentliche Schnittstellen prüfen.
3. Schritt 3: Positive, negative und Berechtigungsfälle abdecken.

10. Produktionsvorbereitung

1. Schritt 1: Runtime-Konfiguration und Secrets unterscheiden.
2. Schritt 2: Assets für Produktion bauen.
3. Schritt 3: Ein Release erzeugen und lokal im Produktionsmodus validieren.

Praxisprojekt

Entwicklung einer kleinen Projekt- und Aufgabenverwaltung mit Benutzerkonten, klassischen Seiten, LiveView-Interaktionen, Ecto-Datenmodell, Contexts, Berechtigungen, Tests und lokalem Produktionsrelease.

Methodik

Kurze fachliche Einführungen wechseln mit Live-Demonstrationen, geführten Implementierungsschritten, eigenständigen Übungen, Code-Reviews, Fehlerszenarien und überprüfbaren Zwischenständen. Sämtliche Übungen bauen auf einem konsistenten Referenzprojekt auf.