Erste Schritte mit Lino

Voraussetzungen

Prüfen Sie vor der Installation von Lino, ob Ihre Umgebung richtig vorbereitet ist:

• ✅ .NET 10.0 SDK oder höher installiert. .NET herunterladen
• ✅ .NET CLI im Terminal verfügbar. Prüfen mit: dotnet --version
• ✅ Git für Versionskontrolle installiert. Git herunterladen
• ✅ Entity Framework Core CLI für migrations-Unterstützung installiert: dotnet tool install --global dotnet-ef
• ✅ OCI-kompatible Containerumgebung wie Docker Desktop oder Podman.

Plattformkompatibilität

Lino ist plattformübergreifend und kann auf den wichtigsten Betriebssystemen verwendet werden:

• ✅ Windows
• ✅ macOS
• ✅ Linux

Installation

Lino wird als globales .NET-Tool verteilt. Stellen Sie vor dem Fortfahren sicher, dass das .NET 10 SDK oder höher installiert ist.

Installieren Sie die neueste Version mit:

dotnet tool install --global Tolitech.Lino

Überprüfen Sie nach der Installation die Funktion von Lino mit:

lino --version

Wenn die Installation erfolgreich war, wird die installierte Version im Terminal angezeigt.

Authentifizierung

Nach der Installation von Lino müssen Sie sich authentifizieren, um auf alle Funktionen zugreifen zu können.

Wenn Sie bereits ein Konto haben, melden Sie sich mit folgendem Befehl an:

lino auth login

Sie werden aufgefordert, Folgendes anzugeben:

• Benutzer: Zuvor registrierte E-Mail-Adresse.
• Passwort: Dem Konto zugeordnetes Passwort.

Falls Sie noch kein Konto haben, registrieren Sie sich direkt über die CLI mit:

lino user register

Geben Sie während der Registrierung Folgendes an:

• Vorname: Vorname des Benutzers.
• Nachname: Nachname des Benutzers.
• E-Mail: E-Mail-Adresse, die auch als Login verwendet wird.
• Passwort: Sicheres Passwort mit mindestens 6 Zeichen.
• Passwortbestätigung: Geben Sie das Passwort zur Validierung erneut ein.

Nach Abschluss der Registrierung wird der Benutzer automatisch authentifiziert.

Spracheinstellungen

Standardmäßig wird die Lino CLI auf Englisch en angezeigt, Sie können die Sprache jedoch nach Ihren Wünschen aus den verfügbaren Optionen ändern:

en | pt | es | de | fr | it | ja | ko | ru | zh

Um eine neue Sprache festzulegen, führen Sie den folgenden Befehl aus:

lino preferences culture set --name <culture>

Ersetzen Sie <culture> durch eine der unterstützten Kulturen. Verwenden Sie zum Beispiel pt für Portugiesisch, en für Englisch oder es für Spanisch.

Alternativ können Sie die Sprache über eine interaktive Liste auswählen mit:

lino preferences culture set

UTF-8-Codierung anpassen (optional)

Für die korrekte Anzeige von Sprachen mit Sonderzeichen (wie Japanisch, Koreanisch, Russisch oder Chinesisch) stellen Sie sicher, dass Ihr Terminal für UTF-8-Codierung konfiguriert ist.

Passen Sie in Windows PowerShell die Codierung mit den folgenden Befehlen an:

[console]::InputEncoding = [System.Text.Encoding]::UTF8

[console]::OutputEncoding = [System.Text.Encoding]::UTF8

Hinweis: Unter Linux, macOS und Windows Terminal ist UTF-8-Unterstützung normalerweise nativ vorhanden. Trotzdem wird empfohlen, die Konfiguration zu prüfen, falls Probleme bei der Zeichenanzeige auftreten.

Verfügbare Befehle

Lino organisiert seine Automatisierung in Befehlsgruppen. Jede Gruppe steht für eine architektonische Absicht: die Lösung erstellen, Services hinzufügen, die Domäne modellieren, APIs bereitstellen, Seiten generieren, Integrationen konfigurieren, migrations steuern, Artefakte versionieren und builds vorbereiten.

Die zuverlässigste Referenz für Ihren Rechner ist die Hilfe der installierten CLI selbst. Verwenden Sie lino --help, um den vollständigen Befehlsbaum anzuzeigen, und verwenden Sie --help in jeder Gruppe, um Optionen, aliases, Pflichtparameter und Beispiele nachzuschlagen.

Da Lino kontinuierlich weiterentwickelt wird, können zwischen Versionen neue Befehle und Optionen erscheinen. Betrachten Sie diese Dokumentation als Orientierung für die Nutzung und bestätigen Sie die genaue Syntax im Terminal, wenn Sie einen Ablauf automatisieren oder jemanden im Team schulen.

Um die Liste der verfügbaren Befehle anzuzeigen, führen Sie den Root-Befehl aus oder fragen Sie die Hilfe explizit ab:

lino
lino --help

lino --help
lino project --help
lino database migrations --help
lino integration operation --help

Um Unterbefehle und Optionen einer beliebigen Gruppe anzuzeigen, verwenden Sie den Befehlsnamen allein oder kombinieren Sie ihn mit --help:

lino <command>
lino <command> --help

Zum Beispiel zeigt die CLI beim Abfragen der Gruppe project die Gruppenbeschreibung, häufige Beispiele und die verfügbaren Unterbefehle an:

lino project --help

BESCHREIBUNG:
    Verwaltet Lino-Projekte.

BEISPIELE:
    lino project new --name MyProject
    lino project list

BEFEHLE:
    new     Erstellt ein neues Projekt.
    list    Listet erstellte Projekte auf.
    delete  Entfernt ein vorhandenes Projekt.

In Beispielen kennzeichnen Werte zwischen <...> Argumente, die durch den echten Wert Ihres Projekts ersetzt werden müssen. Zum Beispiel muss <ProjectName> durch den Namen der Lösung, <ServiceName> durch den Namen des Services und <culture> durch eine unterstützte Kultur wie pt oder en ersetzt werden.

Wichtigste Befehlsgruppen:

Einige Befehle zeigen der Einfachheit halber einen kurzen alias in Klammern an. Die ursprünglichen Namen bleiben die wichtigste Referenz für Lesen, Dokumentation, Schulung, Automatisierung und Support.

Schnellstart

Erstellen Sie mit folgendem Befehl schnell eine moderne, skalierbare .NET-Anwendung, die auf kontinuierliche Weiterentwicklung vorbereitet ist:

lino project new --name <ProjectName>

Ersetzen Sie <ProjectName> durch den echten Namen Ihrer Lösung. Um beispielsweise ein Projekt mit dem Namen MyApp zu erstellen, führen Sie lino project new --name MyApp aus.

Dieser Befehl generiert eine strukturierte .NET solution mit klarer Trennung zwischen Domäne, Anwendung, Infrastruktur, Persistenz, API, Orchestrierung und Tests. Die Anfangsstruktur hilft, architektonische Entscheidungen ab dem ersten commit sichtbar zu halten, und verhindert, dass Geschäftsregeln, Datenzugriff, endpoints und operative Details an derselben Stelle vermischt werden.

Visuell lässt sich eine Anfangslösung namens MyApp so verstehen:

MyApp/
├── MyApp.slnx
├── src/
│   ├── Aspire/
│   │   ├── AppHost/
│   │   │   └── MyApp.AppHost.csproj
│   │   └── ServiceDefaults/
│   │       └── MyApp.ServiceDefaults.csproj
│   └── Services/
│       └── Shared/
│           ├── Api/
│           │   └── MyApp.Shared.Api.csproj
│           ├── Application/
│           │   └── MyApp.Shared.Application.csproj
│           ├── Domain/
│           │   └── MyApp.Shared.Domain.csproj
│           ├── Infrastructure/
│           │   └── MyApp.Shared.Infrastructure.csproj
│           └── Infrastructure.Persistence/
│               └── MyApp.Shared.Infrastructure.Persistence.csproj
└── tests/

Dieser Baum ist ein didaktisches Beispiel für die Struktur, die für das Projekt des Benutzers generiert wird. Er zeigt, wie die Lösung lokale Ausführung, Services, technische Schichten und Tests von Anfang an trennt.

Was das Anfangsprojekt liefert

Die von Lino erstellte Anfangslösung ist bereits nach technischen Verantwortlichkeiten organisiert. Statt nur ein leeres Projekt zu liefern, bereitet die CLI eine Basis mit Schichten und Komponenten vor, die für Unternehmensanwendungen geeignet sind.

Der in <ProjectName> angegebene Name wird Teil der technischen Identität der Lösung. Wählen Sie einen kurzen, stabilen und aussagekräftigen Namen, da er in namespaces, assemblies, Artefakten, Konfigurationen und Referenzen zwischen Komponenten verwendet wird.

Wichtigste Vorteile:

• Explizite Architektur: Trennung zwischen Geschäftsregeln, Use Cases, Infrastruktur, Persistenz und Eingabeverträgen.
• Modulare Weiterentwicklung: Basis vorbereitet für traditionelle Services, modulare Monolithen, Microservices und SaaS-Anwendungen, wenn der Kontext es erfordert.
• Konsistente technische Muster: Unterstützung für DDD, Clean Architecture, CQRS, Ereignisse, Integrationen, migrations, Tests und Observability.
• Weniger mechanische Arbeit: Generierung wiederkehrender Strukturen, damit Entwickler ihre Energie auf Domäne, Regeln, Verträge und Produktentscheidungen konzentrieren können.
• Vorhersehbarerer Code: Namenskonventionen, Ordnerorganisation und Verantwortlichkeiten reduzieren Mehrdeutigkeit zwischen Teammitgliedern.

Mit Lino beginnt der Entwickler nicht mit einem leeren Ordner oder einem generischen template. Er beginnt mit einer meinungsstarken Basis für Unternehmenssysteme, in der jedes generierte Artefakt eine klare technische Funktion hat und inkrementell weiterentwickelt werden kann.