Premiers pas avec Lino

Prérequis

Avant d’installer Lino, vérifiez que votre environnement est correctement préparé :

• ✅ SDK .NET 10.0 ou supérieur installé. Télécharger .NET
• ✅ CLI .NET disponible dans le terminal. Vérifiez avec : dotnet --version
• ✅ Git installé pour le contrôle de version. Télécharger Git
• ✅ Entity Framework Core CLI installée pour la prise en charge des migrations : dotnet tool install --global dotnet-ef
• ✅ Environnement de conteneurs compatible OCI, comme Docker Desktop ou Podman.

Compatibilité de plateforme

Lino est multiplateforme et peut être utilisé sur les principaux systèmes d’exploitation :

• ✅ Windows
• ✅ macOS
• ✅ Linux

Installation

Lino est distribué comme un outil global .NET. Avant de continuer, assurez-vous d’avoir installé le SDK .NET 10 ou supérieur.

Pour installer la version la plus récente, exécutez :

dotnet tool install --global Tolitech.Lino

Après l’installation, validez le fonctionnement de Lino en exécutant :

lino --version

Si l’installation réussit, la version installée sera affichée dans le terminal.

Authentification

Après avoir installé Lino, vous devez vous authentifier pour accéder à toutes les fonctionnalités.

Si vous avez déjà un compte, connectez-vous avec la commande :

lino auth login

Il vous sera demandé d’indiquer :

• Utilisateur : adresse e-mail préalablement enregistrée.
• Mot de passe : mot de passe associé au compte.

Si vous n’avez pas encore de compte, inscrivez-vous directement via la CLI avec :

lino user register

Pendant l’inscription, indiquez :

• Prénom : prénom de l’utilisateur.
• Nom : nom de l’utilisateur.
• E-mail : adresse e-mail qui servira également d’identifiant de connexion.
• Mot de passe : mot de passe sécurisé d’au moins 6 caractères.
• Confirmation du mot de passe : saisissez de nouveau le mot de passe pour validation.

Une fois l’inscription terminée, l’utilisateur sera automatiquement authentifié.

Préférences de langue

Par défaut, la CLI de Lino est affichée en anglais en, mais vous pouvez changer la langue selon votre préférence parmi les options disponibles :

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

Pour définir une nouvelle langue, exécutez la commande suivante :

lino preferences culture set --name <culture>

Remplacez <culture> par l’une des cultures prises en charge. Par exemple, utilisez pt pour le portugais, en pour l’anglais ou es pour l’espagnol.

Vous pouvez également sélectionner la langue dans une liste interactive avec :

lino preferences culture set

Ajustement de l’encodage UTF-8 (facultatif)

Pour un affichage correct des langues avec des caractères spéciaux (comme le japonais, le coréen, le russe ou le chinois), assurez-vous que votre terminal est configuré pour utiliser l’encodage UTF-8.

Dans Windows PowerShell, ajustez l’encodage en exécutant les commandes suivantes :

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

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

Remarque : Sur Linux, macOS et Windows Terminal, la prise en charge d’UTF-8 est généralement native. Il est tout de même recommandé de valider la configuration si un problème d’affichage des caractères survient.

Commandes disponibles

Lino organise son automatisation en groupes de commandes. Chaque groupe représente une intention architecturale : créer la solution, ajouter des services, modéliser le domaine, exposer des APIs, générer des pages, configurer des intégrations, contrôler les migrations, versionner les artefacts et préparer les builds.

La référence la plus fiable pour votre machine est l’aide de la CLI installée elle-même. Utilisez lino --help pour voir l’arborescence complète des commandes et utilisez --help sur n’importe quel groupe pour consulter les options, aliases, paramètres obligatoires et exemples.

Comme Lino évolue en continu, de nouvelles commandes et options peuvent apparaître entre deux versions. Considérez cette documentation comme une orientation d’utilisation et confirmez la syntaxe exacte dans le terminal chaque fois que vous automatisez un flux ou formez quelqu’un dans l’équipe.

Pour afficher la liste des commandes disponibles, vous pouvez exécuter la commande racine ou demander explicitement l’aide :

lino
lino --help

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

Pour afficher les sous-commandes et les options de n’importe quel groupe, utilisez le nom de la commande seul ou combinez-le avec --help :

lino <command>
lino <command> --help

Par exemple, lorsque vous consultez le groupe project, la CLI affiche la description du groupe, des exemples courants et les sous-commandes disponibles :

lino project --help

DESCRIPTION:
    Gère les projets Lino.

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

COMMANDES:
    new     Crée un nouveau projet.
    list    Liste les projets créés.
    delete  Supprime un projet existant.

Dans les exemples, les valeurs entre <...> indiquent des arguments qui doivent être remplacés par la valeur réelle de votre projet. Par exemple, <ProjectName> doit être remplacé par le nom de la solution, <ServiceName> par le nom du service et <culture> par une culture prise en charge, comme pt ou en.

Principaux groupes de commandes :

Certaines commandes affichent un alias court entre parenthèses par commodité. Les noms originaux restent la référence principale pour la lecture, la documentation, la formation, les automatisations et le support.

Démarrage rapide

Créez rapidement une application .NET moderne, évolutive et prête pour une évolution continue avec la commande suivante :

lino project new --name <ProjectName>

Remplacez <ProjectName> par le vrai nom de votre solution. Par exemple, pour créer un projet appelé MyApp, exécutez lino project new --name MyApp.

Cette commande génère une solution .NET structurée avec une séparation claire entre domaine, application, infrastructure, persistance, API, orchestration et tests. La structure initiale aide à garder les décisions architecturales visibles dès le premier commit, en évitant que les règles métier, l’accès aux données, les endpoints et les détails opérationnels soient mélangés au même endroit.

Visuellement, une solution initiale appelée MyApp peut être comprise ainsi :

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/

Cet arbre est un exemple pédagogique de la structure générée pour le projet de l’utilisateur. Il montre comment la solution sépare dès le départ l’exécution locale, les services, les couches techniques et les tests.

Ce que fournit le projet initial

La solution initiale créée par Lino naît déjà organisée par responsabilités techniques. Au lieu de livrer seulement un projet vide, la CLI prépare une base avec des couches et des composants adaptés aux applications d’entreprise.

Le nom indiqué dans <ProjectName> devient une partie de l’identité technique de la solution. Choisissez un nom court, stable et représentatif, car il sera utilisé dans les namespaces, assemblies, artefacts, configurations et références entre composants.

Principaux bénéfices :

• Architecture explicite : séparation entre règles métier, cas d’utilisation, infrastructure, persistance et contrats d’entrée.
• Évolution modulaire : base préparée pour des services traditionnels, monolithes modulaires, microservices et applications SaaS lorsque le contexte l’exige.
• Standards techniques cohérents : prise en charge de DDD, Clean Architecture, CQRS, événements, intégrations, migrations, tests et observabilité.
• Moins de travail mécanique : génération de structures répétitives pour que le développeur concentre son énergie sur le domaine, les règles, les contrats et les décisions produit.
• Code plus prévisible : conventions de nommage, organisation des dossiers et responsabilités réduisent l’ambiguïté entre les membres de l’équipe.

Avec Lino, le développeur ne commence pas depuis un dossier vide ni depuis un template générique. Il commence depuis une base opinionated, pensée pour les systèmes d’entreprise, où chaque artefact généré a une fonction technique claire et peut évoluer de manière incrémentale.