# Identity Microservice (`identity-ms`)

Ce document complète le README JHipster généré (`identity-ms/README.md`) en l'adaptant au contexte du monorepo et du module commun.

## Aperçu
`identity-ms` est un microservice Spring Boot généré avec JHipster 8.11.0.

- Java 17, Maven
- Spring Boot 3 (Web, Security Resource Server, Validation, JPA, Actuator, Undertow)
- PostgreSQL
- JWT (authentification)
- Liquibase
- MapStruct, Lombok
- JHipster Framework 8.11.0
- Dépendance vers la librairie commune: `com.ms.common:ms-common:1.0-SNAPSHOT`
- Docker Compose (services, app)
- Sonar (qualité de code), Jib (images Docker), CI scripts

Références:
- `pom.xml`
- `package.json`
- `.yo-rc.json` (configuration JHipster)
- `src/main/docker/` (fichiers Docker Compose)

## Prérequis
- Java 17 (JDK)
- Maven (ou wrapper `./mvnw`)
- Node.js >= 22.15.0 (pour les scripts npm)
- Docker + Docker Compose (optionnel mais recommandé)

## Dépendance au module commun
Avant de démarrer le microservice, construire et installer la librairie commune en local:
```bash
cd ../common-module
./mvnw clean install
```

Ensuite dans `identity-ms/pom.xml`, la dépendance est déjà référencée:
```xml
<dependency>
  <groupId>com.ms.common</groupId>
  <artifactId>ms-common</artifactId>
  <version>1.0-SNAPSHOT</version>
</dependency>
```

## Configuration et Ports
- Port HTTP par défaut: `8081`
  - Déclaré dans `.yo-rc.json > serverPort`
  - Répliqué dans `package.json > config.backend_port`
- Profils Spring: `dev` (par défaut), `prod`, `e2e`
- Base de données: PostgreSQL
- Authentification: JWT (clé de génération initiale en `.yo-rc.json`, à sécuriser en production)

## Démarrage en développement
Depuis `identity-ms/`:
```bash
./mvnw
# ou via npm
npm run app:start
```

Base de données via Docker (si nécessaire):
```bash
npm run docker:db:up
# arrêt
npm run docker:db:down
```

## Build et Packaging
- Jar (production):
```bash
./mvnw -Pprod clean verify
java -jar target/*.jar
```

- War (optionnel):
```bash
./mvnw -Pprod,war clean verify
```

- Image Docker (Jib):
```bash
npm run java:docker
# ARM64 (Mac M1/M2)
npm run java:docker:arm64
```

## Docker Compose
- Services tiers (db, etc.):
```bash
docker compose -f src/main/docker/services.yml up -d
docker compose -f src/main/docker/services.yml down
```

- Application + services:
```bash
docker compose -f src/main/docker/app.yml up -d
docker compose -f src/main/docker/app.yml down
```

- JHipster Control Center:
```bash
docker compose -f src/main/docker/jhipster-control-center.yml up
```

## Tests et Qualité
- Tests backend:
```bash
./mvnw verify
npm run backend:unit:test
```

- Lint / Checkstyle / NoHTTP:
```bash
npm run backend:nohttp:test
```

- Javadoc:
```bash
npm run backend:doc:test
```

- SonarQube (local):
```bash
docker compose -f src/main/docker/sonar.yml up -d
./mvnw -Pprod clean verify sonar:sonar -Dsonar.login=admin -Dsonar.password=admin
```

## Observabilité et Dépendances clés
- Actuator (health, metrics)
- Micrometer Prometheus simpleclient
- Springdoc OpenAPI (starter webmvc api)
- Liquibase (migrations)
- Testcontainers pour les tests d'intégration (PostgreSQL, JUnit Jupiter)

## API et OpenAPI

- Base URL locale: `http://localhost:8081`
- Actuator:
  - `/management/health`
  - `/management/health/readiness`
  - `/management/health/liveness`
- OpenAPI (si activé):
  - Spéc JSON: `GET /v3/api-docs`
  - Pour une UI Swagger, ajouter `springdoc-openapi-starter-webmvc-ui` et accéder à `/swagger-ui.html`.

Exemples:
```bash
curl -s http://localhost:8081/management/health | jq .
curl -s http://localhost:8081/v3/api-docs | head -n 20
```

JWT (endpoints protégés):
```bash
TOKEN="<votre_token_jwt>"
curl -H "Authorization: Bearer $TOKEN" http://localhost:8081/api/your-resource
```

## Sécurité et Bonnes pratiques
- Regénérer et externaliser la clé JWT pour les environnements non-dev
- Gérer les secrets (DB, JWT, etc.) via variables d’environnement / vault
- Configurer CORS/CSRF et politiques selon le besoin métier
- Revoir les profils Spring et les propriétés sensibles avant déploiement

## CI/CD
- Le projet est compatible avec les générateurs CI JHipster (`jhipster ci-cd`).
- Scripts npm disponibles:
  - `ci:backend:test`, `ci:e2e:*`, `services:up`, etc.
- Un `.gitlab-ci.yml` existe et peut être adapté si besoin.

## Déploiement

### Docker Compose
Des fichiers Compose sont fournis dans `src/main/docker/`.
Exemple (app + services):
```bash
docker compose -f src/main/docker/app.yml up -d
```

### Kubernetes (exemple minimal)
Après avoir construit l'image Docker (via `npm run java:docker` ou pipeline), déployer:
```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: identity-ms
spec:
  replicas: 1
  selector:
    matchLabels:
      app: identity-ms
  template:
    metadata:
      labels:
        app: identity-ms
    spec:
      containers:
        - name: identity-ms
          image: your-registry/identity-ms:latest
          ports:
            - containerPort: 8081
          env:
            - name: SPRING_PROFILES_ACTIVE
              value: prod
---
apiVersion: v1
kind: Service
metadata:
  name: identity-ms
spec:
  selector:
    app: identity-ms
  ports:
    - port: 80
      targetPort: 8081
      protocol: TCP
```

### GitLab CI (exemple)
Exemple de jobs pour builder, tester et construire/pusher l'image:
```yaml
stages: [build, test, docker]

build_backend:
  stage: build
  script:
    - cd identity-ms
    - ./mvnw -ntp -DskipTests package

test_backend:
  stage: test
  script:
    - cd identity-ms
    - ./mvnw -ntp verify

docker_image:
  stage: docker
  variables:
    DOCKER_TLS_CERTDIR: ""
  services:
    - docker:dind
  image: docker:24
  script:
    - cd identity-ms
    - ./mvnw -ntp -DskipTests -Pprod jib:dockerBuild
    - docker tag identity-ms:latest $CI_REGISTRY_IMAGE/identity-ms:latest
    - echo $CI_REGISTRY_PASSWORD | docker login -u $CI_REGISTRY_USER --password-stdin $CI_REGISTRY
    - docker push $CI_REGISTRY_IMAGE/identity-ms:latest
```

## Liens
- README JHipster original: `identity-ms/README.md`
- README Global: `../README.md`
- Module commun: `../common-module/README.md`
