# Configuration réseau pour accéder à MariaDB sur le Raspberry Pi

## Scénarios de connexion

### Scénario 1 : Application Django sur le même RPI que MariaDB

Si votre application Django tourne **dans un autre conteneur Docker** sur le même Raspberry Pi :

```env
# .env
DB_HOST=mariadb  # Nom du conteneur (résolution DNS Docker)
DB_PORT=3306
```

✅ C'est le cas pour la production sur le RPI

### Scénario 2 : Développement sur Mac, MariaDB sur RPI

Si vous développez sur votre **Mac** et que MariaDB est sur le **Raspberry Pi** :

```env
# .env
DB_HOST=192.168.x.x  # IP du Raspberry Pi sur le réseau local
DB_PORT=3306
```

⚠️ Le port 3306 doit être exposé sur le réseau (pas seulement au réseau Docker interne)

## Configuration du conteneur MariaDB sur le RPI

### Vérifier si le port est exposé

```bash
# Sur le Raspberry Pi
docker port mariadb
```

Si vous voyez `3306/tcp -> 0.0.0.0:3306`, le port est bien exposé. ✅

Si vous ne voyez rien, le port n'est pas exposé. ❌

### Exposer le port si nécessaire

Si le conteneur a été créé sans exposer le port, vous avez deux options :

#### Option 1 : Recréer le conteneur (recommandé)

```bash
# Sauvegarder d'abord les données !
docker exec mariadb mysqldump -u root -p --all-databases > backup_all.sql

# Arrêter et supprimer le conteneur
docker stop mariadb
docker rm mariadb

# Recréer avec le port exposé
docker run -d \
  --name mariadb \
  -p 3306:3306 \
  -e MYSQL_ROOT_PASSWORD=votre_mot_de_passe \
  -v mariadb_data:/var/lib/mysql \
  mariadb:latest

# Restaurer les données
docker exec -i mariadb mysql -u root -p < backup_all.sql
```

#### Option 2 : Utiliser un tunnel SSH (temporaire pour dev)

Si vous ne voulez pas modifier le conteneur :

```bash
# Sur votre Mac
ssh -L 3306:localhost:3306 user@raspberry-pi-ip
```

Puis dans votre `.env` :

```env
DB_HOST=127.0.0.1  # Se connecte via le tunnel SSH
DB_PORT=3306
```

## Trouver l'IP du Raspberry Pi

### Sur le Raspberry Pi

```bash
hostname -I
# Exemple de sortie : 192.168.1.100 fe80::xxxx
# Utilisez la première IP (IPv4)
```

Ou :

```bash
ip addr show | grep "inet " | grep -v 127.0.0.1
```

### Depuis votre Mac

```bash
# Si vous connaissez le hostname du RPI
ping raspberrypi.local

# Scanner le réseau (nécessite nmap)
nmap -sn 192.168.1.0/24 | grep -B 2 "Raspberry"
```

## Tester la connexion

### Depuis votre Mac

```bash
# Test 1 : Port ouvert ?
telnet 192.168.1.100 3306
# Si ça se connecte : ✅
# Si "Connection refused" : ❌ Port non exposé ou firewall

# Test 2 : Connexion MySQL
mysql -h 192.168.1.100 -u duhaz_user -p duhaz_blog
# Si ça fonctionne : ✅
```

### Test avec Python

```python
# test_connection.py
import MySQLdb

try:
    conn = MySQLdb.connect(
        host='192.168.1.100',  # IP du RPI
        user='duhaz_user',
        passwd='votre_mot_de_passe',
        db='duhaz_blog',
        port=3306
    )
    print("✅ Connexion réussie!")
    conn.close()
except Exception as e:
    print(f"❌ Erreur: {e}")
```

## Sécurité

### Pour la production

Ne laissez PAS le port 3306 ouvert sur Internet ! Utilisez plutôt :

1. **Réseau Docker interne** : Les conteneurs communiquent entre eux sans exposer le port
2. **Reverse proxy** : Seul le port 80/443 est exposé
3. **VPN** : Pour accéder à distance de manière sécurisée

### Pour le développement local

C'est OK d'exposer le port sur le réseau local (192.168.x.x) si :
- Votre réseau local est sûr (chez vous)
- Vous utilisez un mot de passe fort
- Le pare-feu du RPI bloque les connexions externes

## Configuration recommandée

### Production (Django + MariaDB sur le même RPI)

```yaml
# docker-compose.yml
version: '3.8'
services:
  mariadb:
    image: mariadb:latest
    environment:
      MYSQL_ROOT_PASSWORD: password_fort
      MYSQL_DATABASE: duhaz_blog
      MYSQL_USER: duhaz_user
      MYSQL_PASSWORD: password_fort
    volumes:
      - mariadb_data:/var/lib/mysql
    networks:
      - blog_network
    # PAS de ports: exposés !

  django:
    build: .
    environment:
      DB_HOST: mariadb  # Nom du service
      DB_PORT: 3306
    networks:
      - blog_network
    ports:
      - "8000:8000"

volumes:
  mariadb_data:

networks:
  blog_network:
```

### Développement (Mac → RPI)

```bash
# Sur le RPI : exposer le port
docker run -d --name mariadb -p 3306:3306 ...

# Sur le Mac : .env
DB_HOST=192.168.1.100
DB_PORT=3306
```

## Dépannage

### "Can't connect to MySQL server"

1. ✅ Vérifiez que le conteneur tourne : `docker ps | grep mariadb`
2. ✅ Vérifiez que le port est exposé : `docker port mariadb`
3. ✅ Testez la connexion réseau : `telnet IP 3306`
4. ✅ Vérifiez le pare-feu du RPI : `sudo ufw status`

### "Access denied for user"

1. ✅ Vérifiez les identifiants dans `.env`
2. ✅ Vérifiez que l'utilisateur peut se connecter depuis n'importe où :
   ```sql
   SELECT User, Host FROM mysql.user WHERE User = 'duhaz_user';
   -- Host doit être '%' ou votre IP
   ```

### "Host 'xxx.xxx.xxx.xxx' is not allowed to connect"

L'utilisateur n'a pas le droit de se connecter depuis votre IP :

```sql
-- Sur le RPI
docker exec -it mariadb mysql -u root -p

GRANT ALL PRIVILEGES ON duhaz_blog.* TO 'duhaz_user'@'192.168.1.%';
FLUSH PRIVILEGES;
```

## Résumé des configurations

| Situation | DB_HOST | Port exposé ? |
|-----------|---------|---------------|
| Production (Docker) | `mariadb` | Non |
| Dev local (Mac → RPI) | `192.168.x.x` | Oui |
| Dev avec tunnel SSH | `127.0.0.1` | Non (via SSH) |
| RPI local (même machine) | `localhost` | Oui |
