Einstieg mit Goat

Goat ist ein moderner Codegenerator und eine Automatisierungsumgebung, die dabei hilft, vollständige Anwendungen schnell zu entwickeln, ohne die Kontrolle über den Code zu verlieren.

Statt die Generierung als einmalige Erstellung eines Projekt-Templates zu behandeln, ermöglicht Goat, weitere Änderungen sicher und selektiv in eine bestehende Anwendung einzubringen. Der generierte Code bleibt gewöhnlicher Quellcode — du kannst ihn manuell ändern, weiterentwickeln und genauso committen wie den übrigen Teil des Projekts.

Du kannst ein neues Projekt erstellen mit:

goat init ./my-project \
  --name my-project \
  --git-repo https://github.com/your-user/my-project.git

Der Befehl initialisiert eine Anwendung auf Basis eines vorbereiteten Git-Repositorys und erstellt einen einsatzbereiten Ausgangspunkt für die weitere Arbeit.

Der Standard-Starter von Goat liefert eine auf Go und Angular basierende Anwendung, der Generatormechanismus selbst ist jedoch flexibel und kann an die Architektur sowie die Konventionen eines konkreten Projekts angepasst werden.

Wozu Goat?

Ein großer Teil der Arbeit an Geschäftsanwendungen ist wiederkehrend: Datenmodelle, DTOs, DAOs, Formulare, Endpunkte, Validierung, Migrationen oder grundlegende CRUD-Operationen.

Goat automatisiert diese Ebene, sodass du dich auf das konzentrieren kannst, was die Anwendung tatsächlich unterscheidet:

  • Geschäftslogik,
  • Sicherheit,
  • Qualität der Benutzeroberfläche,
  • Integrationen,
  • Performance,
  • Funktionen, die den Nutzern Mehrwert bieten.

Gleichzeitig hilft ein gemeinsames Anwendungsmodell dabei, Konsistenz zwischen Frontend und Backend zu gewährleisten. Auf seiner Grundlage können unter anderem Entitäten, DTOs, DAOs, API-Endpunkte sowie die entsprechenden Elemente der Benutzeroberfläche generiert werden.

Der Generator soll die Arbeit beschleunigen, nicht den Nutzer in ein vorgegebenes Generierungsmodell einschließen.

Deshalb kannst du Goat dort einsetzen, wo es tatsächlich Zeit spart, und den generierten Code anschließend frei manuell weiterentwickeln.

Sichere Ausführung von Skripten

Eines der zentralen Grundprinzipien von Goat ist die Isolierung der Automatisierung vom Host-System.

Typische Entwicklungswerkzeuge führen Installationsskripte häufig direkt auf dem Rechner des Entwicklers aus. Beispielsweise kann npm install Code aus installierten Abhängigkeiten ausführen.

Goat verringert die mit solchen Skripten verbundene Risikofläche.

Von Goat ausgeführte Skripte laufen in einer isolierten Umgebung und können ausschließlich auf Ressourcen zugreifen, die ihnen explizit bereitgestellt wurden. In einem typischen Szenario bedeutet das vor allem das aktuelle Projektverzeichnis.

Dadurch wird sichergestellt, dass die Automatisierung:

  • keinen uneingeschränkten Zugriff auf das Host-System erhält,
  • keine Dateien außerhalb des aktuellen Projekts verändern sollte,
  • Werkzeuge wie Node.js, npm oder PostgreSQL ausführen kann, ohne sie lokal zu installieren,
  • auf verschiedenen Betriebssystemen eine vergleichbare Laufzeitumgebung beibehält.

Docker stellt hierbei die Isolierungs- und Portabilitätsschicht dar, während Goat eine komfortable Möglichkeit bietet, vollständige Entwicklungsprozesse zu definieren und auszuführen.

Ein Generator, der sich an das Projekt anpasst

Goat geht nicht davon aus, dass generierter Code unverändert bleiben muss.

Du kannst den Code jederzeit manuell bearbeiten. Der Generator sollte Änderungen jedoch möglichst lokal und gezielt einbringen, anstatt bei jedem Durchlauf ganze Anwendungsmodule zu überschreiben.

Dadurch lassen sich zwei Arbeitsweisen kombinieren:

das Generieren wiederkehrender Teile und die manuelle Weiterentwicklung projektspezifischer Teile.

Dieser Ansatz ist besonders wichtig in größeren Projekten, in denen der Generator über viele Monate oder Jahre hinweg mit von Entwicklern weiterentwickeltem Code koexistieren muss.

Goat und KI

Das eingeschränkte, deklarative Projektmodell arbeitet auch gut mit KI-Werkzeugen zusammen.

Anstatt einen großen Teil des Repositorys zu analysieren, kann das Modell häufig mit einer deutlich kleineren Beschreibung der Domäne und der Generatorkonfiguration arbeiten.

Dies ermöglicht:

  • die Menge des an das Modell übergebenen Codes zu begrenzen,
  • die Kosten für den Einsatz von KI zu senken,
  • die Analysezeit des Projekts zu verkürzen,
  • die Anzahl der Stellen zu begrenzen, die die KI ändern muss,
  • die Vorhersehbarkeit der generierten Änderungen zu erhöhen.

KI kann daher vor allem bei der Änderung des Modells und der Anwendungsintention helfen, während Goat diese Änderungen konsistent in Code überträgt.

Dies bedeutet jedoch nicht, dass ausschließlich auf Modellebene gearbeitet werden muss. Wenn sich eine konkrete Änderung direkt im Code einfacher umsetzen lässt, können die generierten Dateien ganz normal bearbeitet werden.

Für wen ist dieses Projekt geeignet

Wähle Goat, wenn du eine Anwendung auf Basis strukturierter Daten, Formulare, APIs und eines Verwaltungsbereichs erstellst und schnell vom Domänenmodell zu einem funktionierenden System gelangen möchtest.

Der grundlegende Workflow ist einfach:

  1. Du erstellst ein Projekt mit goat init,
  2. Du beschreibst Entitäten und Beziehungen in herd/_model.goat,
  3. Du startest den Generator,
  4. Goat erstellt oder aktualisiert die zugehörigen Elemente der Anwendung,
  5. Du entwickelst den generierten Code dort weiter, wo eigene Logik erforderlich ist.

Goat eignet sich besonders gut dort, wo die Anwendung viel wiederkehrende Infrastruktur enthält, gleichzeitig aber eigene Geschäftslogik und weitere manuelle Entwicklung erfordert.

Anforderungen

  • Docker,
  • Go — wenn du go run ./scripts ...-Befehle direkt auf dem Host ausführst,
  • Git sowie Standard-Shell-Werkzeuge.

Du musst PostgreSQL oder Node.js nicht direkt auf dem Computer installieren. Die herd/*.goat-Skripte können die erforderlichen Werkzeuge und Dienste innerhalb von Containern starten.

Schnellstart

1. Projekt erstellen

Führe in einem neuen Verzeichnis Folgendes aus:

goat init ./my-project \
  --name my-project \
  --git-repo https://github.com/your-user/my-project.git

Der Befehl erstellt ein neues Projekt auf Basis eines vorbereiteten Git-Repositorys.

Dadurch erhältst du sofort eine vollständige Projektstruktur, einschließlich:

  • eines Beispiel-Anwendungsmodells,
  • einer Generatorkonfiguration,
  • .goat-Skripten,
  • Beispiel-Fixture-Daten,
  • Dokumentation, die an die aktuelle Projektversion angepasst ist,
  • eines Backends und Frontends, die für die weitere Entwicklung bereit sind.

goat init dient daher nicht nur dazu, ein leeres Projekt zu erstellen, sondern dazu, eine vollständige Startumgebung vorzubereiten, die sofort gestartet, analysiert und angepasst werden kann.

2. Umgebung konfigurieren

Vervollständige die lokale Datei:

.env

Lege keine echten Geheimnisse im Repository ab.

Werte wie Datenbankpasswörter oder GOAT_JWT_SECRET sollten lokal bleiben oder vom Secret-Management-System der jeweiligen Umgebung bereitgestellt werden.

3. Entwicklungsumgebung starten

Führe Folgendes aus:

bash child/dev.sh

Wenn du die Quellwerkzeuge des Projekts direkt verwendest, kannst du auch Folgendes nutzen:

go run ./scripts run:script --path=herd/dev.goat

Das Skript richtet eine vollständige lokale Entwicklungsumgebung ein.

Beim ersten Start führt Goat unter anderem Folgendes aus:

  • startet die erforderlichen Dienste,
  • generiert die Anwendung,
  • bereitet die Datenbank vor,
  • führt Migrationen aus,
  • erstellt die erforderlichen Projektkomponenten,
  • lädt Daten aus herd/fixture.goat,
  • startet Backend und Frontend.

4. Öffne die Anwendung

Nach Abschluss der Initialisierung ist die Anwendung verfügbar unter:

http://localhost:8080

Zusätzliche Dienste:

  • pgAdmin: http://localhost:5050,
  • PostgreSQL: localhost:5433.

Dank der vom Projekt bereitgestellten Fixtures kannst du bereits beim ersten Start nicht nur eine funktionierende Anwendung sehen, sondern auch Beispieldaten und die Dokumentation, die der aktuell verwendeten Goat-Version entspricht.

Wie geht es weiter?

Nach dem Start des Projekts arbeitest du in der Regel im folgenden Zyklus:

Änderung des Modells oder Codes
        ↓
goat re
        ↓
Überprüfung der Änderungen
        ↓
manuelle Nachbearbeitung
        ↓
Tests

Das Anwendungsmodell befindet sich in:

herd/_model.goat

Nach dessen Änderung kannst du den Code erneut generieren:

goat re

Überprüfe anschließend das Ergebnis:

git diff

und führe die Tests aus:

goat run:script --path=herd/test.goat

Nächste Schritte

  • Gehe Schritt für Schritt [von goat init zum ersten Modell](/doc/de/neues-projekt).
  • Lerne die [Projektarchitektur](/doc/de/projektarchitektur) kennen.
  • Konfiguriere die [lokale Umgebung](/doc/de/umgebungskonfiguration).
  • Sieh dir an, wie du das [Datenmodell ändern und Code generieren](/doc/de/datenmodell-und-codegenerierung) kannst.
  • Erfahre, wie du Daten dem [KI-Assistenten über das Harness-Modul](/doc/de/harness-modul) bereitstellst.
  • Lerne den [lokalen Entwicklungsworkflow](/doc/de/lokale-entwicklung) kennen.
  • Informiere dich über [Tests und verfügbare Befehle](/doc/de/tests-und-befehle).