Auf dieser Seite
Astro: der letzte einfache Einstieg in die moderne Webentwicklung?
Wer heute Webentwicklung lernen will, landet schnell bei einem Werkzeugkasten, der mehr Fragen stellt als beantwortet: Client-Framework, Meta-Framework, Hydration, Zustandsverwaltung, Build-Konfiguration. Die eigentliche Idee des Webs, eine Anfrage und eine Antwort aus HTML, verschwindet dahinter.
Ich unterrichte als Gastdozent das Modul Internettechnologien im vierten Bachelorsemester an der IBS IT & Business School Oldenburg. Die Studierenden planen und entwickeln in Teams innerhalb von sechs Wochen eine eigene Webanwendung. Dafür brauche ich einen Stack, der sich zu Beginn des Semesters in kurzer Zeit vollständig erklären lässt. Nach einem gründlichen Vergleich vieler Stacks fiel meine Wahl auf JavaScript mit Astro.
Meine These vorweg: Mit KI-Assistenten werden die Grundlagen wichtiger, nicht unwichtiger. Dieser Artikel zeigt, wie der Kurs aufgebaut ist, wo der Einstieg hakt und ob Astro wirklich der letzte einfache Einstieg ist.
Das Ziel: eine vollständige Anwendung
Gelernt wird an einem Starterprojekt, das die Teams anschließend als Grundlage für ihr eigenes Projekt übernehmen. Es enthält, was fast jede Webanwendung braucht:
- Registrierung, Login und Logout
- Persönliche Profile mit Profilbild
- Eine Benutzerverwaltung mit Suche
- Rollen und Rechte für User und Admin
- Ein automatisiertes Deployment
Der Stack dahinter ist bewusst klein: HTML, CSS und JavaScript, Bun als Laufzeit, Astro als Framework, MongoDB mit Mongoose als Datenbank und htmx für Interaktivität. In jeder Vorlesung kommt ein Baustein hinzu, jeweils mit einer praktischen Übung und einem kurzen Quiz.
Die Studierenden bringen drei Semester Java mit und lernen in diesem Semester die Sprache des Webs: JavaScript. Ein Java-Stack wäre vertraut, aber umständlicher. Zwischen Java-Code und der ersten HTML-Seite stehen Build-Werkzeug, Framework, Annotationen und eine Template Engine, und für alles, was im Browser passiert, braucht es am Ende doch JavaScript. Mit Bun und JavaScript ist der Weg kürzer: Ein HTTP-Server besteht aus einer Datei und startet mit einem Befehl. JavaScript und TypeScript brauchen die Studierenden in der Berufspraxis als Softwareentwickler:innen ohnehin.
Git gehört fest dazu: Versionskontrolle ist die Grundlage der Teamarbeit im Projekt.
Erst die Grundlagen, dann das Framework
Astro taucht erst im sechsten von vierzehn Kapiteln meines Vorlesungsplans auf. Davor stehen unter anderem drei Themen, die jedes Framework überleben.
HTTP. Client fragt, Server antwortet. Methoden beschreiben die Aktion, URLs die Ressource, Statuscodes das Ergebnis. Header transportieren Metadaten, Cookies erlauben es, über das zustandslose Protokoll hinweg Sitzungen abzubilden. Wichtig für später: Links und Formulare lösen Anfragen aus, und HTML-Formulare können seit den Neunzigern nur GET und POST.
JavaScript. Nur der Teil, der ständig gebraucht wird: const und let, Objekte und Arrays, Arrow Functions, map, filter und find, Destructuring, Optional Chaining (?.) und ??, async/await mit try/catch und ES-Module.
JavaScript auf dem Server. Mit Bun ist ein HTTP-Server in wenigen Zeilen geschrieben. Bun setzt auf die Web-APIs, die auch der Browser kennt: Request, Response, URL, URLSearchParams. Dazu kommen eingebaute Helfer wie Bun.password (Argon2id) und Bun.file() sowie das automatische Laden von .env-Dateien.
Am Ende dieses Kapitels liefert der selbst geschriebene Server bereits dynamisches HTML aus:
// server.js
Bun.serve({
routes: {
"/users": {
GET: async () => {
const users = await getAllUsers();
const html = `
<html>
<body>
<ul>${users.map((u) => `<li>${u.username}</li>`).join("")}</ul>
</body>
</html>
`;
return new Response(html, {
headers: {"Content-Type": "text/html; charset=utf-8"},
});
},
},
},
});
Das funktioniert, und genau deshalb ist es lehrreich. Die Studierenden merken selbst, was fehlt: Das Routing wird unübersichtlich, HTML in Zeichenketten ist mühsam, alles wiederholt sich, und jedes Projekt bekommt eine eigene Struktur. Dazu kommt eine Sicherheitslücke, die man leicht übersieht: Ein Benutzername wie <script>…</script> landet unverändert im HTML und wird im Browser ausgeführt (Cross-Site Scripting). Ein Framework ist an dieser Stelle keine Vorgabe mehr, sondern die Antwort auf ein erlebtes Problem.
Warum Astro und kein anderes Framework
Ein Framework gibt Struktur vor, damit man weniger Entscheidungen treffen muss. Im Unterschied zu einer Bibliothek ruft es den eigenen Code auf, nicht umgekehrt. Die Auswahl habe ich in drei Gruppen sortiert:
| Gruppe | Beispiele | Für den Kurs |
|---|---|---|
| Client-Frameworks | React, Vue, Angular, Svelte | Für hoch interaktive Anwendungen, Offline-Betrieb und Echtzeit. Braucht das Starterprojekt nicht. |
| Server-Frameworks | Hono, Express, Fastify, NestJS | Gut für reine Daten-APIs. HTML entsteht über Template-Engines oder, wie bei Hono, über eingebautes JSX. Routing aus Dateien und eine feste Projektstruktur fehlen, beides muss jedes Team selbst festlegen. |
| Meta-Frameworks mit festem Client-Framework | Next.js, Nuxt, SvelteKit, Analog | Viele Funktionen, aber komplex und mit steiler Lernkurve. |
Astro ist ebenfalls ein Full-Stack-Meta-Framework, aber an kein Client-Framework gebunden. Es rendert zuerst auf dem Server, liefert ohne weiteres Zutun kein JavaScript an den Browser aus und bleibt nah an HTML. Die Seite aus dem Bun-Beispiel sieht in Astro so aus:
---
// src/pages/users.astro
const users = await getAllUsers();
---
<html>
<body>
<ul>
{users.map(u => <li>{u.username}</li>)}
</ul>
</body>
</html>
Oben JavaScript, unten HTML, beides wird auf dem Server ausgewertet. Der Dateiname ist die URL. Ausdrücke in geschweiften Klammern maskiert Astro automatisch. Die Lücke aus dem Bun-Beispiel ist damit für Textinhalte geschlossen. Offen bleibt sie bei set:html und bei Attributen wie href, in denen eine eingegebene URL landet, etwa mit javascript:. Dort braucht es weiterhin eine eigene Prüfung. Im Kurs heißt das „HTML mit Superpowers“. Bun bleibt dabei die Laufzeit: Astro ergänzt Routing, Templates, Komponenten und den Build. Die Web-APIs und Bun-Helfer aus dem Kapitel davor gelten weiter.
Besonders wertvoll finde ich, dass Astro nebenbei auf die Client-Frameworks vorbereitet. Die Template-Syntax ähnelt JSX aus React, und Komponenten, Props und Slots gibt es in React, Vue und Svelte gleichermaßen. Wer später eines davon lernt, kennt die Konzepte schon und muss vor allem das Neue verstehen: Zustand im Browser. Zugleich arbeitet Astro mit Web-Standards wie ES-Modulen und den Objekten Request und Response.
Was Astro den Lernenden abnimmt
Routing aus der Dateistruktur. src/pages/login.astro wird zu /login, src/pages/users/[id].astro zu /users/123, der Parameter steht in Astro.params.id. Eine Routing-Konfiguration gibt es nicht.
Eine Komponente hat bis zu vier Teile. Das Frontmatter zwischen den --- läuft nur auf dem Server. Darunter folgt das Template mit Ausdrücken in geschweiften Klammern. Optional kommen ein <script> für den Browser und ein <style> hinzu, dessen CSS nur für diese Komponente gilt. Bedingungen und Listen im Template sind gewöhnliches JavaScript: ternärer Operator, && und map().
Formulare mit Web-Standards. Eine Seite verarbeitet ihren eigenen POST. Was die Studierenden im HTTP-Kapitel gelernt haben, wenden sie hier direkt an:
---
// src/pages/register.astro (vereinfacht)
import { registerUser } from '@/services/user/register-user.js';
import { ValidationError } from '@/lib/error/validation-error.js';
let error = '';
if (Astro.request.method === 'POST') {
const data = await Astro.request.formData();
const username = data.get('username')?.toString() ?? '';
const email = data.get('email')?.toString() ?? '';
const password = data.get('password')?.toString() ?? '';
try {
await registerUser({ username, email, password });
return Astro.redirect('/login');
} catch (err) {
if (!(err instanceof ValidationError)) throw err;
error = err.message;
}
}
---
{error && <p role="alert">{error}</p>}
<form method="POST">
<label>Benutzername <input type="text" name="username" /></label>
...
<button type="submit">Registrieren</button>
</form>
Astro.request ist ein gewöhnliches Request-Objekt, formData() die Standard-API. Angezeigt werden nur fachliche Fehler wie ein vergebener Benutzername. Alles andere wird weitergeworfen, damit keine internen Meldungen im Browser landen. Der Redirect nach dem erfolgreichen POST ist das Muster POST-Redirect-GET: Ein Neuladen der Seite sendet das Formular nicht noch einmal. Die Erfolgsmeldung reist als Flash Message in einem Cookie mit, das beim Auslesen gelöscht wird.
Komponenten, Props und Layouts. Wiederkehrendes HTML wird zur Komponente, Daten kommen über Astro.props hinein. Ein Layout ist eine Komponente mit einem <slot />, in den der Seiteninhalt eingesetzt wird. Ein Import-Alias @/ in der tsconfig.json ersetzt Ketten aus ../. Tailwind CSS ist im Starterprojekt eingerichtet, muss aber nicht benutzt werden.
Interaktivität mit htmx statt Client-Framework
Für Löschen, Ändern und Suchen ohne vollständiges Neuladen kommt htmx hinzu, eingebunden mit einem einzigen Script-Tag und ohne Build-Schritt. htmx löst über HTML-Attribute Anfragen mit allen HTTP-Methoden aus und fügt die Antwort an einer Stelle der Seite ein. Die Antwort ist HTML, kein JSON.
<button
hx-delete={`/partials/users/${user.id}`}
hx-confirm="Möchten Sie dieses Konto wirklich löschen?"
hx-target={`#user-${user.id}`}
hx-swap="outerHTML"
>
Löschen
</button>
Die Gegenseite ist ein Astro Partial, also eine .astro-Datei ohne HTML-Gerüst:
---
// src/pages/partials/users/[id].astro
import { removeUser } from '@/services/admin/remove-user.js';
import { isAdminRole } from '@/lib/user/roles.js';
import { ForbiddenError } from '@/lib/error/forbidden-error.js';
export const partial = true;
const { id } = Astro.params;
const { currentUser } = Astro.locals;
if (Astro.request.method === 'DELETE') {
if (!currentUser || !isAdminRole(currentUser.role)) {
throw new ForbiddenError('Keine Berechtigung');
}
await removeUser(id, currentUser.id);
} else {
Astro.response.status = 405;
Astro.response.headers.set('Allow', 'DELETE');
}
---
Die Prüfung im Partial ist Absicht. Ein Partial ist eine eigene URL, und die DELETE-Anfrage lässt sich auch ohne Button absenden. Den Löschen-Button für andere Rollen auszublenden, schützt den Endpunkt also nicht. Deshalb prüft das Partial die Rolle selbst, auch wenn niemand angemeldet ist.
Eine leere Antwort mit Status 200 lässt das Element verschwinden. Bei Status 204 tauscht htmx dagegen nichts aus, und das Element bleibt stehen. Das ist ein beliebter Stolperstein, weil 204 nach dem HTTP-Kapitel „richtiger“ wirkt.
Gegenüber einer API-Route haben Partials einen Vorteil: Sie benutzen dieselben Komponenten wie die vollständige Seite. Die Benutzerkarte wird einmal geschrieben und beim ersten Laden ebenso verwendet wie bei der Live-Suche. Die Suche sendet 300 Millisekunden nach dem letzten Tastendruck eine Anfrage. Von Hand mit DOM- und Fetch-API bräuchte sie rund zwanzig Zeilen JavaScript, noch ohne Fehlerbehandlung. Soll eine Antwort mehrere Stellen der Seite aktualisieren, etwa Liste und Zähler, erledigt das hx-swap-oob.
Im Starterprojekt schickt die Suche ihre Anfrage per POST. Nach der HTTP-Semantik aus dem Kurs wäre GET passender, weil eine Suche nichts verändert. Die Umstellung ist klein: hx-get statt hx-post, und das Partial liest den Suchbegriff aus Astro.url.searchParams statt aus formData(). Über diese Abweichung lohnt sich eine Diskussion mit den Studierenden.
Die Regel im Kurs: htmx für Teilaktualisierungen, Inline-Bearbeitung und alles jenseits von GET und POST. Für Seitenwechsel wie Login und Registrierung bleibt es beim klassischen Formular, damit die Browser-Historie stimmt.
Daten, Anmeldung, Uploads
Die zweite Hälfte des Kurses macht aus den Seiten eine Anwendung. Das Framework tritt dabei zurück, die Architektur wird wichtiger.
Daten. MongoDB speichert Dokumente, die wie JavaScript-Objekte aussehen. Mongoose legt Schema, Validierung und Indizes darüber. Die Ordner haben feste Aufgaben: models/ beschreibt die Datenstruktur, services/ enthält die Fachlogik und alle Datenbankzugriffe, lib/ enthält Hilfsfunktionen ohne Datenbankzugriff. Seiten und Komponenten rufen Services auf und nie die Datenbank. Fehler bekommen eigene Klassen, die zu HTTP-Statuscodes passen, zum Beispiel 422 für ungültige Formulardaten. Eine verbreitete Falle: unique: true ist in Mongoose kein Validator, sondern legt nur einen eindeutigen Index an. Einen doppelten Benutzernamen meldet deshalb erst MongoDB, mit dem Fehlercode 11000. Der Service übersetzt diesen Code in eine verständliche Meldung.
Anmeldung. Sessions sind in Astro eingebaut. Die Session speichert nur die ID der angemeldeten Person, Passwörter werden mit Bun.password gehasht. Nach dem Login sollte die Session eine neue ID bekommen (Astro.session.regenerate()), sonst ist Session Fixation möglich. Gegen Cross-Site Request Forgery prüft Astro bei serverseitig gerenderten Seiten standardmäßig, ob Formularanfragen von derselben Website kommen (security.checkOrigin). Den Rest erledigt eine Kette aus vier kleinen Middlewares:
// src/middleware/index.js
import { sequence } from 'astro:middleware';
export const onRequest = sequence(errorHandler, db, loadUser, auth);
Fehler abfangen, Datenbank verbinden, Benutzer:in laden, Zugriff prüfen. Danach steht Astro.locals.currentUser in jeder Seite bereit, und geschützte Routen sowie der Admin-Bereich werden zentral über den URL-Pfad geprüft statt in jeder Datei einzeln. Ein kleiner Request-Handler ordnet die HTTP-Methoden einer Seite, setzt Statuscodes und leitet auch htmx-Anfragen korrekt um.
Uploads. Das Profilbild kommt per multipart/form-data und PUT über ein htmx-Partial. Geprüft werden MIME-Type, Dateiendung und Größe (höchstens 5 MB). Den MIME-Type schickt der Browser mit, er ist also nicht vertrauenswürdig. Sicherer ist es, zusätzlich die ersten Bytes der Datei zu prüfen, etwa mit dem Paket file-type, und SVG auszuschließen, weil SVG Skripte enthalten kann. Der Dateiname wird als UUID neu erzeugt, der Originalname nie verwendet. Die Dateien liegen außerhalb von public/, die Metadaten in MongoDB. Ausgeliefert wird über eine eigene Route mit Schutz gegen Path Traversal und mit ETag-Caching.
Zusammenarbeit. Den Abschluss bilden Git mit Feature Branches, Pull Requests und Code Reviews sowie Hinweise zur Projektarbeit: Kanban-Board, kurze Stand-ups, ein Zeitplan aus Planung, Kernfunktionen und Feinschliff. Die wichtigste Warnung dort lautet, nicht voreilig weitere Technologien einzusetzen.
Wo es nicht einfach ist
„Einfach“ heißt nicht „ohne Stolperstellen“. Einige gehören zum Stoff:
- Die Grenze zwischen Server und Browser. Astros Frontmatter läuft auf dem Server,
<script>im Browser. Diese Trennung verläuft innerhalb einer einzigen Datei und muss ausdrücklich gelernt werden. Sie ist die erste Quizfrage zum Thema. - Die Template-Syntax ist nicht HTML.
map()und der ternäre Operator im Markup setzen JavaScript voraus. Ohne das Kapitel davor bleibt das Zauberei. - Server-Side Rendering muss eingeschaltet werden. Nötig ist ein Adapter, etwa
@astrojs/node. Er läuft auch unter Bun und bringt für die eingebauten Sessions gleich einen dateibasierten Speicher mit. Mitoutput: 'server'rendert Astro jede Seite auf dem Server, ohne diese Einstellung nur Seiten mitexport const prerender = false. Für eine Anwendung mit Login istoutput: 'server'die naheliegende Wahl. Außerdem startet Astro standardmäßig unter Node.js. Für Bun muss die Laufzeit ausdrücklich erzwungen werden, etwa mitbunx --bun astro dev. Das gilt auch für den Betrieb: Code mitBun.passwordoderBun.file()läuft unter Node.js nicht. - Eine zweite Bibliothek für Interaktivität. htmx ist klein, aber
hx-target,hx-swapund Partials sind ein eigenes Denkmodell. - Die Grenze des Ansatzes. Ein gemeinsam bearbeitetes Dokument oder ein Zeichenwerkzeug baut man so nicht. Dafür gibt es Client-Frameworks, und Astro kann sie sehr gut einbinden. Für Formulare, Listen und Profile braucht es sie nicht.
Was im Laufe der Jahre weggefallen ist
Der Kurs sah nicht immer so aus. Anfangs lief er auf einem Java-Stack, im Laufe der Jahre habe ich ihn auf JavaScript umgestellt. Auch Docker stand im Lehrplan und wurde wieder gestrichen, um den Kurs zu vereinfachen und die kognitive Belastung der Studierenden in Grenzen zu halten. Die meisten haben wenig oder keine Vorerfahrung in der Webentwicklung.
Hinter beiden Entscheidungen steht dieselbe Abwägung. Die Zeit für die technischen Grundlagen zu Beginn des Semesters ist knapp. Gut betreute Projektarbeit in den Wochen danach bringt den Studierenden mehr als eine weitere Technologie.
Warum KI die Grundlagen wichtiger macht
KI-Assistenten sind im Kurs von Anfang an erlaubt. Es gilt eine Regel: Wer Code abgibt, muss ihn erklären können. Ob das gelingt, zeigen Quizfragen, Reviews und die Präsentationen der Teams.
Macht KI die Grundlagen überflüssig? Ich halte das Gegenteil für richtig. Der Schwerpunkt verschiebt sich vom Schreiben zum Lesen und Prüfen. Ein Assistent erzeugt in Sekunden eine Seite mit Formular, Session und Datenbankzugriff. Ob sie stimmt, erkennt nur, wer weiß, warum nach einem POST eine Weiterleitung folgt, dass das Frontmatter nur auf dem Server läuft und was ein Partial zurückgibt.
Die Fehler, die dabei entstehen, sind selten offensichtlich. Sie sehen plausibel aus und fallen beim Bedienen nicht auf. Zwei Beispiele aus diesem Artikel: Fehlt im Partial oben die Prüfung der Rolle, funktioniert in jedem Klicktest alles, solange der Löschen-Button nur für Admins erscheint. Eine von Hand geschickte DELETE-Anfrage löscht trotzdem. Und ein Upload, der nur dem vom Browser gemeldeten MIME-Type vertraut, lässt sich täuschen. Beide Fehler zeigen sich erst bei einer Anfrage, die man selbst schickt. Erkennen kann beides nur, wer HTTP und die Grenze zwischen Server und Browser verstanden hat.
Richtig eingesetzt hilft KI auch beim Lernen. Sie erklärt Fehlermeldungen, beantwortet Fragen zu fremdem Code und liefert Varianten zum Vergleichen. Das Verstehen ersetzt sie nicht. Sie hilft dann, wenn man zuerst selbst eine Erklärung versucht und die Antwort der KI daran misst. Wer gleich die fertige Erklärung liest, hat schnell das Gefühl, etwas verstanden zu haben, ohne es selbst erklären zu können. Spätestens im Review oder in der Präsentation zeigt sich das.
Astro kommt dem entgegen. Zwischen Anfrage und fertiger Seite steckt wenig Magie, deshalb können auch Einsteigende generierten Code nachvollziehen. Je mehr ein Framework im Hintergrund erledigt, etwa mit Server Components, mehreren Caching-Schichten und verteilten Grenzen zwischen Server- und Client-Code, desto schwerer wird das.
Den Einwand, dass mit KI ohnehin nur das Ergebnis zählt, beantworte ich in einem eigenen Artikel.
Der letzte einfache Einstieg?
Der letzte sicher nicht. Frameworks kommen und gehen, das steht so auch auf meinen Folien, und der Kurs selbst hat seinen Stack schon einmal gewechselt. Aber für meinen Kurs ist Astro derzeit der Einstieg, bei dem zwischen den Grundlagen und einer fertigen Anwendung mit Login, Datenbank und Uploads am wenigsten Framework im Weg steht.
Was die Studierenden lernen, ist zum größten Teil kein Astro-Wissen: HTTP-Methoden und Statuscodes, Request und FormData, Cookies und Sessions, POST-Redirect-GET, die Trennung von Seiten, Services und Modellen. Das gilt auch in jedem anderen Stack. Die Wahl von Astro ist deshalb eine Entscheidung für die Lehre, kein Urteil über andere Stacks.
Einfach ist der Einstieg also aus einem bestimmten Grund: Astro versteckt das Web nicht. Wer zuerst einen Server von Hand geschrieben hat, erkennt in jeder Astro-Seite wieder, was dort passiert. Die Reihenfolge trägt mehr als das Werkzeug. Erst das Problem, dann die Abstraktion. Und wer die Grundlagen kennt, kann auch prüfen, was ein KI-Assistent daraus macht.
Nach demselben Prinzip baue ich meine Workshops und Schulungen für Entwicklungsteams auf: erst die Grundlagen, an denen sich generierter Code prüfen lässt, dann das Werkzeug. Das hilft Teams, die mit KI-Assistenten schneller Code erzeugen, als sie ihn sicher beurteilen können.
Thema für Ihr Projekt?
Passende Leistung: Workshops und Schulungen. Schildern Sie mir kurz, worum es geht. Ich melde mich mit einer ersten Einschätzung.
Projekt anfragen