# Domaine, HTTPS et sécurité de base — appv2dev.datalab0.com

## Contexte validé

Le déploiement public validé utilise :

```txt
Domaine DEV : appv2dev.datalab0.com
IP publique Proxmox : 147.135.131.39
VM privée Ubuntu : 192.168.100.10
Accès SSH : port public 2222 -> VM 22
Accès HTTPS : ports publics 80/443 -> VM 80/443
```

Le domaine DEV permet d’éviter l’accès brut par IP et prépare une séparation propre entre environnements :

```txt
appv2dev.datalab0.com      -> environnement DEV
appv2.datalab0.com         -> futur environnement PROD éventuel
appv2staging.datalab0.com  -> futur environnement STAGING éventuel
```

## DNS OVH

L’enregistrement DNS ajouté pour le DEV est :

```dns
appv2dev        IN A     147.135.131.39
```

Test DNS :

```bash
nslookup appv2dev.datalab0.com
```

Résultat attendu :

```txt
Name:   appv2dev.datalab0.com
Address: 147.135.131.39
```

## Reverse proxy HTTPS

Le HTTPS est géré par Nginx Proxy Manager, installé dans la même VM Docker que l’application.

Architecture :

```txt
Internet
  ↓
https://appv2dev.datalab0.com
  ↓
IP publique Proxmox 147.135.131.39:443
  ↓ NAT
VM privée 192.168.100.10:443
  ↓
Nginx Proxy Manager
  ↓ proxy HTTP
DataLab0 Docker reverse-proxy :8080
```

## Installation Nginx Proxy Manager

Dossier utilisé :

```bash
mkdir -p ~/npm
cd ~/npm
```

Fichier `docker-compose.yml` :

```yaml
services:
  npm:
    image: 'jc21/nginx-proxy-manager:latest'
    restart: unless-stopped
    ports:
      - '80:80'
      - '81:81'
      - '443:443'
    volumes:
      - ./data:/data
      - ./letsencrypt:/etc/letsencrypt
```

Lancement :

```bash
docker compose up -d
```

Interface d’administration :

```txt
http://147.135.131.39:81
```

Identifiants initiaux Nginx Proxy Manager :

```txt
Email: admin@example.com
Password: changeme
```

Ils doivent être changés immédiatement après la première connexion.

## NAT Proxmox pour Nginx Proxy Manager

Les ports publics nécessaires :

```txt
80  -> 192.168.100.10:80
443 -> 192.168.100.10:443
81  -> 192.168.100.10:81, interface admin NPM
```

Commandes Proxmox :

```bash
iptables -t nat -A PREROUTING -i vmbr0 -p tcp --dport 80 -j DNAT --to-destination 192.168.100.10:80
iptables -t nat -A POSTROUTING -p tcp -d 192.168.100.10 --dport 80 -j MASQUERADE

iptables -t nat -A PREROUTING -i vmbr0 -p tcp --dport 443 -j DNAT --to-destination 192.168.100.10:443
iptables -t nat -A POSTROUTING -p tcp -d 192.168.100.10 --dport 443 -j MASQUERADE

iptables -t nat -A PREROUTING -i vmbr0 -p tcp --dport 81 -j DNAT --to-destination 192.168.100.10:81
iptables -t nat -A POSTROUTING -p tcp -d 192.168.100.10 --dport 81 -j MASQUERADE
```

Rendre persistant :

```bash
netfilter-persistent save
```

## Proxy Host NPM

Dans Nginx Proxy Manager :

```txt
Proxy Hosts -> Add Proxy Host
```

Configuration :

```txt
Domain Names: appv2dev.datalab0.com
Scheme: http
Forward Hostname / IP: 192.168.100.10
Forward Port: 8080
```

Options conseillées :

```txt
Block Common Exploits: enabled
Websockets Support: enabled
```

Onglet SSL :

```txt
Request a new SSL Certificate
Force SSL: enabled
HTTP/2 Support: enabled
Agree to Let's Encrypt Terms of Service: enabled
```

URL finale validée :

```txt
https://appv2dev.datalab0.com
```

## Point d’attention certificat SSL

Si l’erreur suivante apparaît :

```txt
ERR_SSL_UNRECOGNIZED_NAME_ALERT
```

cela signifie généralement que NPM répond sur `443`, mais que le certificat n’a pas été correctement généré.

Cause fréquente : le port `80` n’était pas encore accessible au moment du challenge Let's Encrypt.

Correction :

1. vérifier que les NAT `80` et `443` existent ;
2. retourner dans le Proxy Host NPM ;
3. onglet SSL ;
4. demander à nouveau un certificat ;
5. réactiver `Force SSL`.

## Sécurité SSH validée

L’accès SSH public utilise :

```txt
147.135.131.39:2222 -> 192.168.100.10:22
```

Connexion depuis Windows :

```powershell
ssh -i $HOME\.ssh\id_ed25519 -p 2222 admin@147.135.131.39
```

La clé publique du PC est placée dans :

```txt
/home/admin/.ssh/authorized_keys
```

Permissions attendues :

```bash
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys
```

## Configuration SSH sécurisée

Fichier :

```bash
sudo nano /etc/ssh/sshd_config
```

Options validées :

```txt
PubkeyAuthentication yes
PasswordAuthentication no
PermitRootLogin no
```

Tester la configuration avant redémarrage :

```bash
sudo sshd -t
```

Si la commande ne retourne rien, la configuration est valide.

Redémarrer SSH :

```bash
sudo systemctl restart ssh
```

Important : garder une session SSH ouverte pendant le test, puis ouvrir une deuxième session depuis le PC pour confirmer que l’accès par clé fonctionne toujours.

## Fail2ban

Fail2ban a été installé et activé dans la VM :

```bash
sudo apt install -y fail2ban
sudo systemctl enable fail2ban
sudo systemctl start fail2ban
```

Vérification :

```bash
sudo systemctl status fail2ban
```

Statut attendu :

```txt
Active: active (running)
```

Fail2ban protège notamment contre les tentatives de brute force SSH.

## Ports publics actuellement utilisés

```txt
2222 -> SSH VM
80   -> NPM / Let's Encrypt HTTP challenge
443  -> HTTPS public appv2dev.datalab0.com
81   -> interface admin Nginx Proxy Manager
8080 -> accès direct historique à DataLab0, à fermer/protéger plus tard
9001 -> console MinIO, à fermer/protéger plus tard si inutile publiquement
```

## Recommandation prochaine sécurité

À court terme, réduire l’exposition publique :

- fermer ou restreindre `8080`, car HTTPS passe maintenant par `443` ;
- fermer ou restreindre `81`, interface admin NPM ;
- fermer ou restreindre `9001`, console MinIO ;
- ne garder publiquement que `80`, `443` et éventuellement `2222`.

## État validé

À ce stade, le socle dispose de :

- domaine DEV ;
- HTTPS Let’s Encrypt ;
- reverse proxy Nginx Proxy Manager ;
- SSH par clé uniquement ;
- root SSH interdit ;
- fail2ban actif ;
- règles NAT persistantes ;
- Docker Compose applicatif fonctionnel.