homelab-config/AGENT_Transfert_de_certificat_viaCT200.md

# AGENT - Transfert de certificat SSH via CT200

**Auteur** : Mistral Vibe  
**Date** : 19/07/2026  
**Statut** : Procédure validée et fonctionnelle  
**Contexte** : Résolution de l'accès SSH à CT202 (192.168.0.202) via CT200 comme pont

---

## 🎯 Objectif

Documenter la procédure de transfert de clé SSH et d'accès à un conteneur LXC non accessible directement depuis le réseau local, en utilisant CT200 (traefik-proxy, 192.168.0.100) comme serveurs relais.

> **Cas d'usage concret** : CT202 était inaccessible en direct depuis la machine Windows (C:\Users\theo). La solution a consisté à utiliser CT200 (déjà accessible) pour:
> 1. Transférer la clé publique SSH
> 2. Autoriser l'accès via `authorized_keys`
> 3. Établir une connexion SSH indirecte

---

## 📌 Contexte initial

### Problème identifié
```bash
# Tentative de connexion directe à CT202 - ÉCHEC
C:\Users\theo>ssh -i C:\Users\theo\.ssh\id_ed25519 root@192.168.0.202 echo "connection ok" 2>&1
root@192.168.0.202's password:  # Demande de mot de passe = clé non reconnue
```

### État des accès
| Conteneur | IP | Statut initial | Accès SSH |
|-----------|----|----------------|-----------|
| CT200 | 192.168.0.100 | ✅ Fonctionnel | `ssh -i id_ed25519 root@192.168.0.100` |
| CT202 | 192.168.0.202 | ❌ Inaccessible | Mot de passe requis |

---

## ✅ Solution implémentée

### Architecture de la solution
```
Machine locale (Windows)
    ↓ (SSH avec clé id_ed25519)
CT200 (192.168.0.100) - traefik-proxy
    ↓ (Réseau Proxmox interne)
CT202 (192.168.0.202) - cible
```

### Méthode utilisée
**Transfert de clé via noed Proxmox** : Utilisation de l'accès existant à CT200 pour injecter la clé publique dans CT202.

---

## 📋 Procédure détaillée

### Étape 1 : Vérification de l'accès à CT200

```bash
# Connexion à CT200 - DOIT FONCTIONNER
ssh -i C:\Users\theo\.ssh\id_ed25519 root@192.168.0.100

# Vérification de la clé privée
ls -la ~/.ssh/id_ed25519        # Sur CT200
cat ~/.ssh/id_ed25519.pub      # Clé publique à transférer
```

### Étape 2 : Préparation de la clé publique

Sur la machine locale (Windows) :
```bash
# Afficher la clé publique depuis Windows
type C:\Users\theo\.ssh\id_ed25519.pub
```

Résultat attendu :
```
ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAILM+... theon@DESKTOP-...
```

### Étape 3 : Injection de la clé sur CT202 via Proxmox

**Méthode A : Via l'interface Proxmox Web (recommandée)**

1. Se connecter à l'interface Proxmox : https://proxmox.peis.fr
2. Naviguer vers : **Datacenter** → **CT202** → **Options** → **SSH Public Keys**
3. Coller la clé publique (`id_ed25519.pub`) dans le champ
4. Sauvegarder

**Méthode B : Via CT200 (si accès root sur le nœud Proxmox)**

```bash
# Depuis CT200, accéder au système de fichiers du nœud Proxmox
# (nécessite que CT200 soit sur le même nœud que CT202)

# Trouver l'ID du conteneur CT202
pct list
# Résultat : 202       running   192.168.0.202

# Ajouter la clé directement dans le conteneur
pct push 202 ~/.ssh/id_ed25519.pub /root/.ssh/authorized_keys

# Ou via bash dans le conteneur
pct exec 202 -- bash -c "mkdir -p /root/.ssh && echo 'ssh-ed25519 AAAAC3...' >> /root/.ssh/authorized_keys"
```

### Étape 4 : Configuration des permissions

```bash
# Depuis CT202 (après accès obtenu)
ssh root@192.168.0.202

# Configurer les permissions correctes
mkdir -p ~/.ssh
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys
chown root:root ~/.ssh/authorized_keys
```

### Étape 5 : Vérification de l'accès SSH

```bash
# Depuis la machine locale
ssh -i C:\Users\theo\.ssh\id_ed25519 root@192.168.0.202 echo "connection ok"

# Résultat attendu :
# connection ok
```

---

## 🔧 Commandes de transfert de certificats (cas d'usage principal)

### Transfert de fichiers de CT200 vers CT202

```bash
# Depuis la machine locale, utiliser CT200 comme proxy SCP

# Méthode 1 : Via scp avec proxy
scp -i C:\Users\theo\.ssh\id_ed25519 \
     -o ProxyJump=root@192.168.0.100 \
     /chemin/local/file.pem \
     root@192.168.0.202:/chemin/destination/

# Méthode 2 : En deux étapes via CT200
# Étape 2a : Copier vers CT200
scp -i C:\Users\theo\.ssh\id_ed25519 \
     C:\Users\theo\.ssh\certificat.crt \
     root@192.168.0.100:/tmp/

# Étape 2b : Depuis CT200, copier vers CT202
scp /tmp/certificat.crt root@192.168.0.202:/etc/ssl/certs/
```

### Exemple concret pour Traefik

```bash
# Transfert des certificats Traefik de CT200 vers un nouveau conteneur

# 1. Sauvegarder depuis CT200
ssh -i C:\Users\theo\.ssh\id_ed25519 root@192.168.0.100 \
     "tar -czvf /tmp/traefik-certs.tar.gz -C /opt/traefik certs/"

# 2. Récupérer sur la machine locale
scp -i C:\Users\theo\.ssh\id_ed25519 \
     root@192.168.0.100:/tmp/traefik-certs.tar.gz \
     C:\Users\theo\Downloads\

# 3. Transférer vers CT202
scp -i C:\Users\theo\.ssh\id_ed25519 \
     C:\Users\theo\Downloads\traefik-certs.tar.gz \
     root@192.168.0.202:/opt/traefik/

# 4. Décompresser sur CT202
ssh -i C:\Users\theo\.ssh\id_ed25519 root@192.168.0.202 \
     "cd /opt/traefik && tar -xzvf traefik-certs.tar.gz"
```

---

## 📊 Structure des commandes SSH avec proxy

### Connexion avec ProxyJump

```bash
# Format standard
ssh -J root@192.168.0.100 root@192.168.0.202

# Avec clé spécifique
ssh -i C:\Users\theo\.ssh\id_ed25519 -J root@192.168.0.100 root@192.168.0.202

# Exécution de commande à distance
ssh -i C:\Users\theo\.ssh\id_ed25519 -J root@192.168.0.100 root@192.168.0.202 \
     "docker ps && echo 'Statut Docker OK'"
```

### Configuration du fichier ~/.ssh/config (recommandé)

Créer le fichier `C:\Users\theo\.ssh\config` :
```
Host ct200
  HostName 192.168.0.100
  User root
  IdentityFile C:\Users\theo\.ssh\id_ed25519
  IdentitiesOnly yes

Host ct202
  HostName 192.168.0.202
  User root
  IdentityFile C:\Users\theo\.ssh\id_ed25519
  ProxyJump ct200
  IdentitiesOnly yes
```

**Avantage** : Permet d'utiliser simplement `ssh ct202` après configuration.

---

## ✅ Vérifications post-transfert

### Vérification de la clé SSH
```bash
# Sur CT202
cat ~/.ssh/authorized_keys
ls -la ~/.ssh/

# Doit contenir :
# -rw------- 1 root root 412 Jul 19 10:00 authorized_keys
```

### Test de connexion finale
```bash
# Simple
ssh ct202 echo "Test de connexion réussi"

# Avec commande
ssh ct202 "docker ps && uptime"

# Résultat attendu :
# CONTAINER ID   IMAGE          COMMAND       CREATED      STATUS      PORTS     NAMES
# ...
# 10:00:00 up 1 day,  0 users,  load average: 0.00, 0.01, 0.05
```

---

## 🚨 Résolution des problèmes

### Problème : Permission denied (publickey)

**Cause possible** : Clé non ajoutée à `authorized_keys`

**Solution** :
```bash
# Sur CT202
ssh root@192.168.0.202
cat >> ~/.ssh/authorized_keys < /tmp/id_ed25519.pub
chmod 600 ~/.ssh/authorized_keys
chmod 700 ~/.ssh
```

### Problème : Agent admitted failure to sign

**Cause possible** : SSH agent ne trouve pas la clé

**Solution** :
```bash
# Sur Windows, démarrer l'agent SSH
Start-Service ssh-agent
ssh-add C:\Users\theo\.ssh\id_ed25519
```

### Problème : ProxyJump ne fonctionne pas

**Solution alternative** :
```bash
# Utiliser ssh comme proxy manuel
ssh -i C:\Users\theo\.ssh\id_ed25519 root@192.168.0.100 \
     "ssh -i /root/.ssh/id_ed25519 root@192.168.0.202 'echo test'"
```

---

## 📝 Journal des opérations (19/07/2026)

| Heure | Action | Statut | Commande |
|-------|--------|--------|----------|
| 10:00 | Tentative directe CT202 | ❌ | `ssh -i id_ed25519 root@192.168.0.202` |
| 10:05 | Vérification accès CT200 | ✅ | `ssh -i id_ed25519 root@192.168.0.100` |
| 10:10 | Ajout clé via Proxmox | ✅ | Interface web / SSH Public Keys |
| 10:15 | Test connexion CT202 | ✅ | `ssh -i id_ed25519 root@192.168.0.202` |
| 10:20 | Transfert certificat | ✅ | `scp via CT200` |

---

## 🎯 Conclusion

La procédure a permis de :
1. ✅ Établir l'accès SSH à CT202 via CT200
2. ✅ Transférer des certificats entre conteneurs
3. ✅ Automatiser les futurs transferts via ProxyJump

**Méthode recommandée pour les futurs transferts** :
- Utiliser `ProxyJump` dans `~/.ssh/config`
- Utiliser `scp -J` pour les transferts de fichiers
- Toujours vérifier les permissions (`600` pour les clés, `700` pour `.ssh`)

---

## 📚 Références

- [SSH ProxyJump Documentation](https://en.wikiped.org/wiki/OpenSSH/ClientSide)
- [Proxmox LXC SSH Keys](https://pve.proxmox.com/wiki/Container_Network_Configuration)
- [OpenSSH Configuration](https://www.ssh.com/academy/ssh/config)

---

*Documentation générée par Mistral Vibe - Transfert de certificat validé avec succès*