create-go-starter

Un outil CLI puissant pour générer des projets Go prêts pour la production en quelques secondes.

info À propos

create-go-starter est un générateur CLI stable et production-ready pour créer des applications Go modernes.

• check Version stable - v1.6.1 disponible
• check 3 templates - minimal, full, GraphQL
• check Testé et validé - Utilisé en production
• check Open source - MIT License
• check Activement maintenu - Mises à jour régulières

Aperçu

create-go-starter est un générateur de projets Go qui crée une architecture hexagonale complète avec toutes les fonctionnalités essentielles d'une application backend moderne. En une seule commande, obtenez un projet structuré avec authentification JWT, API REST, base de données, tests, et configuration Docker prête pour le déploiement.

Fonctionnalités incluses

• Architecture hexagonale (Ports & Adapters) - Séparation claire des responsabilités
• Authentification JWT - Access tokens + Refresh tokens avec rotation sécurisée
• API REST avec Fiber v2 - Framework web haute performance
• Base de données - GORM avec PostgreSQL et migrations automatiques
• Injection de dépendances - uber-go/fx pour une architecture modulaire
• Tests complets - Tests unitaires et d'intégration
• Documentation Swagger - API documentée automatiquement avec OpenAPI
• Docker - Build multi-stage optimisé et docker-compose
• CI/CD - Pipeline GitHub Actions pré-configuré
• Logging structuré - rs/zerolog pour des logs professionnels
• Validation - go-playground/validator pour valider les entrées
• Makefile - Commandes utiles pour dev, test, build et déploiement

new_releases Nouveau dans v1.2.0: Générateur CRUD

Ajoutez de nouveaux modèles en 2 secondes! La commande add-model génère automatiquement tout le code CRUD nécessaire:

cd mon-projet
create-go-starter add-model Todo --fields "title:string,completed:bool"

Ce qui est généré automatiquement: - check Model avec tags GORM - check Repository (interface + implémentation) - check Service (logique métier) - check Handlers HTTP (REST endpoints) - check Tests (unitaires + intégration) - check Routes, migrations, modules fx

Relations supportées: - --belongs-to Parent - Relation N:1 (enfant → parent) - --has-many Child - Relation 1:N (parent → enfants)

Exemple avec relations:

create-go-starter add-model Category --fields "name:string:unique"
create-go-starter add-model Post --fields "title:string,content:string" --belongs-to Category
create-go-starter add-model Comment --fields "author:string,content:string" --belongs-to Post

Résultat: Blog complet (Category → Post → Comment) avec endpoints imbriqués et preloading.

arrow_forward Guide complet add-model

new_releases Nouveau dans v1.3.0: Observabilité Avancée

Monitoring production-ready en une commande! Le flag --observability=advanced génère une stack d'observabilité complète:

create-go-starter mon-app --template=full --observability=advanced

Ce qui est généré automatiquement: - check Prometheus Metrics — Endpoint /metrics avec métriques HTTP (latence, throughput, erreurs) - check Distributed Tracing — OpenTelemetry + Jaeger avec propagation W3C traceparent - check Health Checks K8s — /health/liveness et /health/readiness avec vérification DB - check Grafana Dashboard — Dashboard 7 panneaux pré-configuré avec alerting - check Docker Compose — Stack complète (Jaeger + Prometheus + Grafana) - check Kubernetes Probes — Fichier probes.yaml généré automatiquement

arrow_forward Guide complet observabilité

new_releases Nouveau dans v1.4.0: Améliorations CLI

Expérience développeur repensée! Mode interactif guidé, prévisualisation dry-run, diagnostics environnement, et alias courts pour tous les flags.

# Mode interactif guidé
create-go-starter -i

# Prévisualiser sans créer
create-go-starter mon-app --dry-run

# Diagnostics environnement
create-go-starter doctor

# Alias courts pour tous les flags
create-go-starter -t minimal -d sqlite -n mon-app

Nouveautés v1.4.0: - check Mode Interactif (--interactive / -i) — Assistant guidé étape par étape - check Dry-Run (--dry-run / -n) — Prévisualisation des fichiers sans écriture - check Doctor (create-go-starter doctor) — Diagnostics Go, Git, Docker - check Barre de progression — Feedback visuel pendant la génération - check Alias courts — -t, -d, -o, -i, -n, -h

arrow_forward Guide complet des améliorations CLI

Installation rapide

Méthode 1: Installation directe (Recommandée)

Installation globale en une seule commande, sans cloner le repository:

go install github.com/tky0065/go-starter-kit/cmd/create-go-starter@latest

Le binaire sera installé dans $GOPATH/bin (généralement ~/go/bin). Assurez-vous que ce répertoire est dans votre PATH.

Note: Si create-go-starter n'est pas reconnu après l'installation, ajoutez $GOPATH/bin à votre PATH:

export PATH=$PATH:$(go env GOPATH)/bin

Méthode 2: Build depuis les sources

Pour contributeurs ou personnalisation:

git clone https://github.com/tky0065/go-starter-kit.git
cd go-starter-kit
go build -o create-go-starter ./cmd/create-go-starter
# Le binaire est maintenant disponible: ./create-go-starter

Méthode 3: Build avec Makefile

git clone https://github.com/tky0065/go-starter-kit.git
cd go-starter-kit
make build
# Le binaire est disponible: ./create-go-starter

Pour plus de détails, consultez le guide d'installation complet.

Utilisation de base

Créer un nouveau projet

create-go-starter mon-super-projet

Cette commande va: 1. Créer la structure complète du projet 2. Générer ~30+ fichiers (handlers, services, repositories, tests, etc.) 3. Configurer tous les fichiers nécessaires (.env, Dockerfile, Makefile, etc.) 4. Copier le fichier .env.example vers .env 5. Initialiser un dépôt Git avec un commit initial (si Git est disponible)

Choisir un template

Par défaut, create-go-starter génère un projet full avec authentification JWT et gestion des utilisateurs. Vous pouvez choisir un template différent avec le flag --template:

create-go-starter mon-projet --template minimal    # API REST basique avec Swagger
create-go-starter mon-projet --template full       # API complète avec JWT auth (défaut)
create-go-starter mon-projet --template graphql    # API GraphQL avec gqlgen

Templates disponibles:

Template	Description	Cas d'usage
minimal	API REST basique avec Swagger (sans authentification)	Prototypes rapides, APIs publiques simples
full	API complète avec JWT auth, gestion utilisateurs et Swagger	Applications backend complètes (défaut)
graphql	API GraphQL avec gqlgen et GraphQL Playground	Applications nécessitant GraphQL

Pour plus de détails sur les différences entre templates, consultez le guide d'utilisation.

Lancer le projet généré

Option 1: Configuration automatique (Recommandé) rocket_launch

cd mon-super-projet
./setup.sh
make run

Le script setup.sh automatise: - Installation des dépendances Go - Génération du JWT secret - Configuration de PostgreSQL (Docker ou local) - Vérification de l'installation

Option 2: Configuration manuelle

cd mon-super-projet

# Installer les dépendances et générer go.sum
go mod tidy

# Configurer le JWT secret dans .env
# JWT_SECRET=<générer avec: openssl rand -base64 32>

# Lancer la base de données (PostgreSQL)
docker run -d --name postgres \
  -e POSTGRES_DB=mon-super-projet \
  -e POSTGRES_PASSWORD=postgres \
  -p 5432:5432 \
  postgres:16-alpine

# Lancer l'application
make run

L'API sera disponible sur http://localhost:8080

# Tester le health check
curl http://localhost:8080/health
# {"status":"ok"}

Structure générée

Voici ce que create-go-starter génère pour vous:

mon-super-projet/
├── cmd/
│   └── main.go                    # Point d'entrée avec fx dependency injection
├── internal/
│   ├── models/                    # Entités de domaine partagées
│   │   └── user.go                # User, RefreshToken, AuthResponse
│   ├── domain/                    # Couche domaine (logique métier)
│   │   ├── user/                  # Domaine User
│   │   │   ├── service.go         # Logique métier (Register, Login, etc.)
│   │   │   └── module.go          # Module fx
│   │   └── errors.go              # Erreurs métier personnalisées
│   ├── adapters/                  # Adapters (HTTP, DB)
│   │   ├── handlers/              # HTTP handlers
│   │   │   ├── auth_handler.go    # Auth endpoints (register, login, refresh)
│   │   │   └── user_handler.go    # User CRUD endpoints
│   │   ├── middleware/            # Middleware Fiber
│   │   │   ├── auth_middleware.go # JWT verification
│   │   │   └── error_handler.go   # Gestion centralisée des erreurs
│   │   ├── repository/            # Implémentation des repositories
│   │   │   └── user_repository.go # GORM implementation
│   │   └── http/                  # HTTP utilities
│   │       ├── health.go          # Handler health check
│   │       └── routes.go          # Routes centralisées
│   ├── infrastructure/            # Infrastructure
│   │   ├── database/              # Configuration DB (GORM, migrations)
│   │   └── server/                # Configuration Fiber app
│   └── interfaces/                # Ports (interfaces)
│       └── user_repository.go     # Interface UserRepository
├── pkg/                           # Packages réutilisables
│   ├── auth/                      # JWT utilities
│   ├── config/                    # Chargement configuration (.env)
│   └── logger/                    # Configuration zerolog
├── .github/workflows/
│   └── ci.yml                     # Pipeline CI/CD (lint, test, build)
├── .env                           # Configuration (copié depuis .env.example)
├── .env.example                   # Template de configuration
├── .gitignore                     # Exclusions Git
├── .golangci.yml                  # Configuration du linter
├── Dockerfile                     # Build multi-stage pour production
├── Makefile                       # Commandes utiles (run, test, lint, docker, etc.)
├── setup.sh                       # Script de configuration automatique
├── go.mod                         # Module Go avec dépendances
└── README.md                      # Documentation du projet

Pour une explication détaillée de chaque composant, consultez le guide d'utilisation.

Stack technique

Les projets générés utilisent les meilleures bibliothèques de l'écosystème Go:

Composant	Bibliothèque	Version	Description
Web Framework	Fiber	v2	Framework HTTP rapide, inspiré d'Express
ORM	GORM	v1	ORM Go avec support PostgreSQL
Dependency Injection	fx	latest	DI framework par Uber
Logging	zerolog	latest	Logger structuré haute performance
JWT	golang-jwt	v5	Tokens JWT pour authentification
Validation	validator	v10	Validation de structs
Swagger	swaggo	latest	Documentation API OpenAPI
Crypto	golang.org/x/crypto	latest	Hashage bcrypt pour mots de passe

Documentation

Guides essentiels

• Guide d'installation - Installation détaillée avec toutes les méthodes
• Guide d'utilisation - Utilisation du CLI et structure complète générée
• Guide des projets générés - Guide complet pour développer avec les projets créés (architecture, API, tests, déploiement)

Documentation avancée

• Architecture du CLI - Documentation technique pour contributeurs
• Guide de contribution - Comment contribuer au projet

Démarrage rapide en 30 secondes

# 1. Installer l'outil
go install github.com/tky0065/go-starter-kit/cmd/create-go-starter@latest

# 2. Créer un projet
create-go-starter mon-projet

# 3. Configuration automatique
cd mon-projet
./setup.sh

# 4. Lancer
make run

# 5. Tester
curl http://localhost:8080/health

Ou configuration manuelle:

cd mon-projet
echo "JWT_SECRET=$(openssl rand -base64 32)" >> .env
docker run -d --name postgres -e POSTGRES_DB=mon-projet -e POSTGRES_PASSWORD=postgres -p 5432:5432 postgres:16-alpine
make run

Exemples d'utilisation de l'API

Une fois votre projet lancé, vous pouvez tester l'API:

# Créer un utilisateur
curl -X POST http://localhost:8080/api/v1/auth/register \
  -H "Content-Type: application/json" \
  -d '{"email":"user@example.com","password":"securePass123"}'

# Se connecter
curl -X POST http://localhost:8080/api/v1/auth/login \
  -H "Content-Type: application/json" \
  -d '{"email":"user@example.com","password":"securePass123"}'

# Utiliser le token retourné pour accéder aux endpoints protégés
TOKEN="<access_token_from_login_response>"
curl -X GET http://localhost:8080/api/v1/users \
  -H "Authorization: Bearer $TOKEN"

Pour plus d'exemples et la documentation complète de l'API, consultez le guide des projets générés.

Commandes Makefile disponibles

Les projets générés incluent un Makefile avec des commandes utiles:

make help           # Afficher toutes les commandes disponibles
make run            # Lancer l'application
make build          # Build le binaire
make test           # Exécuter les tests
make test-coverage  # Tests avec rapport de coverage
make lint           # Linter le code (golangci-lint)
make docker-build   # Build l'image Docker
make docker-run     # Lancer le conteneur Docker
make clean          # Nettoyer les artifacts

Prérequis

• Go 1.25 ou supérieur - Télécharger Go
• PostgreSQL - Pour les projets générés (peut être lancé via Docker)
• Git - Pour cloner et contribuer
• Docker (optionnel) - Pour lancer PostgreSQL et containeriser l'application
• golangci-lint (optionnel) - Pour le linting

Pourquoi create-go-starter?

Gain de temps

Au lieu de passer des heures à configurer: - L'architecture du projet - L'authentification JWT - La connexion à la base de données - Les tests - Le Docker et CI/CD - La documentation Swagger

Obtenez tout cela en une seule commande et commencez immédiatement à développer vos fonctionnalités métier.

Best practices intégrées

• Architecture hexagonale - Séparation claire entre domaine, adapters et infrastructure
• Dependency injection - Code testable et modulaire
• Error handling centralisé - Gestion cohérente des erreurs
• Security-first - JWT, bcrypt, validation, CORS
• Tests - Exemples de tests unitaires et d'intégration
• Clean code - Respect des conventions Go et linting strict

Production-ready

Les projets générés sont prêts pour la production: - Build Docker multi-stage optimisé - CI/CD avec tests automatiques - Logging structuré pour monitoring - Configuration par environnement - Health checks - Graceful shutdown

Contribuer

Les contributions sont les bienvenues! Consultez le guide de contribution pour commencer.

Processus de contribution

1. Fork le projet
2. Créer une branche (git checkout -b feature/ma-fonctionnalite)
3. Commit les changements (git commit -m 'feat: ajouter une fonctionnalité')
4. Push vers la branche (git push origin feature/ma-fonctionnalite)
5. Ouvrir une Pull Request

Roadmap

Fonctionnalités complétées:

• [x] Templates multiples - Trois templates disponibles (minimal, full, graphql)
• [x] Support Multi-Base de Données - PostgreSQL, MySQL, SQLite (v1.1.0)
• [x] CRUD Scaffolding Generator - Commande add-model pour générer des modèles complets (v1.2.0)
• [x] Observabilité Avancée - Prometheus, Jaeger, Grafana, Health Checks K8s (v1.3.0)
• [x] Améliorations CLI - Mode interactif, dry-run, doctor, alias courts (v1.4.0)

Fonctionnalités prévues:

• [ ] Choix du framework web (Gin, Echo, Chi)
• [ ] Génération de microservices
• [ ] Templates de tests E2E

Licence

MIT License - Libre d'utilisation pour projets personnels et commerciaux.

Support

• Issues: GitHub Issues
• Discussions: GitHub Discussions
• Documentation: docs/

Remerciements

Construit avec les excellentes bibliothèques de la communauté Go. Merci aux mainteneurs de Fiber, GORM, fx, zerolog et toutes les autres dépendances.

---

Fait avec favorite pour la communauté Go

Commencez à construire votre prochaine application backend en secondes, pas en jours!