GMKtec Mini PC N95 (Turbo 3.4 GHz) 12ème Gen. 4 coeurs 4 threads et 6 Mo de cache 8 Gb DDR4 RAM + 256 Gb SSD Wifi 5 + BT 5.0

Connecter un écran au port HDMI Connecter un clavier à un port USB Insérer une clé USB avec une image ISO Proxmox Connecter l'alimentation

Démarrer le PC, en principe il ne devrait pas y avoir de changement à faire au niveau du BIOS.
L'installation de Proxmox démarre:

• choisir “Install proxmox VE (grahical)
  

• Accepter la license d'utilisation

• Garder la sélection du disque ou sera installé Proxmox

• Choisir le pays: Switzerland
• Garder la Time zone: Europe/Zurich
• Changer le Keyboard Layout: Swiss-French

• Créer un mot de passe root (2x)
• Définir un e-mail: sysadmin@cpacon.com

• Garder l'interface de management définie
• Définir le Hostname: pvetest3.test.cpacon.com
• Donner une adresse IP: 192.168.50.x/24
• Donner la gateway: 192.168.50.254
• Donner le DNS Server: 8.8.8.8 A voir si je le modifie par la suite

L'installation se fait, puis le PC redémarre, il faut enlever la clé USB.

Installer le PC et le connecter au réseau
Se connecter à la page d'administration: [adresse_ip:8006]]
Aller dans le >_ Shell
Lancer la ligne de commande: bash -c “$(curl -fsSL https://raw.githubusercontent.com/community-scripts/ProxmoxVE/main/tools/pve/post-pve-install.sh)” (Source: https://community-scripts.org/scripts/post-pve-install)

• Start the Proxmox VE Post Install Script (y/n): y
• Deb822 sources detected: <Ok>
• PVE-ENTERPRISE: disable
• CEPH-ENTERPRISE: disable
• PVE-NO-SUBSCRIPTION: yes
• PVETEST: yes
• SUBSCRIPTION NAG: yes
• Support Subscription: <Ok>
• HIGH AVAILABILITY: no
• UPDATE: yes

Attendre que le script s'execute.

• Post-install Reminder: <Ok>
• REBOOT: yes

Changer la configuration du vmbr0:

• Enlever l'adresse IP et la GW
• Clicker la case “Vlan aware”
• Clicker la case “Advanced”
• ajouter les vlan IDs: 210 500 voir si il faudra en ajouter d'autres

Créer un Linux VLAN: Create/Linux VLAN

• vlan500
• IPv4/CIDR: 192.168.50.x/24
• Gateway (IPv4): 192.168.50.254
• Vlan raw device: nic0
• Comment: pve Mgmt

Appuyer sur le bouton “Apply Configuration”
Il faut adapter le switch pour gérer les Vlan taggé et on devrait récupérer le management.

Dans “Datacenter”, “Storage”, on ajoute les disques du SAN-3 avec le bouton “Add”
SMB/CIFS:

• ID: nas-backup
• Server: 192.168.21.193
• Username: proxmox_svr
• Password: voir doc
• Share: proxmox_backups
• Content: Disk image, ISO image, Container template, Backup, Container

NFS:

• ID: pve-storage
• Server: 192.168.21.193
• Export: /volume1/proxmox-test
• Content: Disk Image, Container

Datacenter/System/Hosts
192.168.50.101 pvetest1.test.cpacon.com pvetest1
192.168.50.102 pvetest2.test.cpacon.com pvetest2
192.168.50.103 pvetest3.test.cpacon.com pvetest3

Datacenter/Permissions/Users
Ajouter un ou des utilisateurs si nécessaire.

Dans Datacenter/Cluster, sur le premier noeud, il faut créer un cluster avec le bouton “Create Cluster”
Sur les noeuds suivants, il faut copier les informations du cluster avec le bouton “Join Information”, puis aller sur le noeud à ajouter, et appuyer sur le bouton “Join Cluster”.
Copier les informations du cluster et donner le mot de passe root.
Attendre que celà se passe.

Depuis un node, cliquer sur “Create VM”
Donner un VM ID et un nom, en cliquant la case “Advanced”, on peut aussi donner des Tags - puis Next
Choisir le “Storage” si nécessaire (par exemple le “nas-backup”), puis l'image ISO (debian-13.xxx) - puis Next
Cliquer sur la case “Qemu Agent” - puis Next
Choisir le “Storage” si nécessaire (par exemple le “pve-storage”, la teille du disque - puis Next
Choisir le nombre de Sockets et core - puis Next
Choisir le mémoire - puis Next
Choisir le réseau et vlan - puis Next
Confirmer avec “Finish”
Démarrer la VM

Choisir l'installation graphique “Graphical install”
Choisir la langue - French - Français
Choisir le pays - Suisse
Choisir le clavier - Suisse romand
Après l'essai de trouver un DHCP, choisir de “Configurer vous-même le réseau”
Configurer l'adresse IP, la passerelle, le serveur de nom, le nom de la machine et le domaine
Définir le mot de passe “root”
Créer un compte avec le nom de l'utilisateur
Donner l'identifiant (adm_xx) et le mot de passe
Partitionner le disque “Assisté - utiliser un disque entier”, choisir le disque
Choisir le schéma (Tout dans une seule partition ou partition /home, /car et /tmp séparé)
Terminer le partitionnement, confirmer par “Oui”
Pas besoin d'autres supports d'installation → “Non”
Choisir le pays du miroir (Suisse) et le serveur
Pas de mandataire HTTP
Ne pas participer à l'étude statistique →“Non”
Pour une installation simple, décocher les cases “environnement de bureau Debian”, ”… GNOME“ et coder “serveur SSH” et laisser les “utilitaires usuels du système”
Installer le programme de démarrage GRUB → “Oui”
Choisir le /dev/sda proposé
Continuer pour redémarrer

Login en “root” depuis la console de PVE
Mise à jour de la liste des paquets: apt update
Mise à jour des paquets: apt upgrade
Installation de sudo: apt install sudo
Ajoute de l'utilisateur adm_xx dans le groupe sudo: usermod -aG sudo adm_xx

Installation selon https://docs.docker.com/engine/install/debian/

Désintaller les package en confliz: sudo apt remove $(dpkg –get-selections docker.io docker-compose docker-doc podman-docker containerd runc | cut -f1)

# Add Docker's official GPG key:
sudo apt update
sudo apt install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

# Add the repository to Apt sources:
sudo tee /etc/apt/sources.list.d/docker.sources < <EOF
Types: deb
URIs: https://download.docker.com/linux/debian« Suites: $(. /etc/os-release && echo “$VERSION_CODENAME”)
Components: stable
Architectures: $(dpkg –print-architecture)
Signed-By: /etc/apt/keyrings/docker.asc
EOF

sudo apt update

sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Vérification que docker fonctionne: sudo systemctl status docker
Démarrage de docker manuellement: sudo systemctl start docker

Créer un groupe docker (si il n'existe pas déjà): sudo groupadd docker
Ajouter un utilisateur au groupe: sudo usermod -aG docker adm_xx
Eventuellement réactiver le groupe: newgrp docker

Pour tester que docker fonctionne avec un container: docker run hello-world

Installation selon https://docs.docker.com/engine/swarm/
Création du manager du swarm: sudo docker swarm init –advertise-addr <MANAGER-IP>
Ajoute des worker avec la commande indiquée à la création du manager

docker run <NOM_CONTAINER> docker info

Télécharger les images: docker compose pull
Démarrer les containers: docker compose up -d
Arrêter les container: docker compose down
Afficher les logs: docker compose logs -f
docker compose ps

Récupérer la commande pour joindre un node au swarm (sur le manager): docker swarm join-token worker
affiche les nodes du swarm: docker node ls
Démarre une stack de container via un fichier compose: docker stack deploy

Installation selon https://docs.goauthentik.io/install-config/install/docker-compose/
Créer un dossier /opt/docker-compose/authentik: sudo mkdir -p /opt/docker-compose/authentik
Aller dans le dossier: cd /opt/docker-compose/authentik
Créer le fichier compose.yaml: sudo nano compose.yaml

services:
postgresql:
env_file:
- .env
environment:
POSTGRES_DB: ${PG_DB:-authentik}
POSTGRES_PASSWORD: ${PG_PASS:?database password required}
POSTGRES_USER: ${PG_USER:-authentik}
healthcheck:
interval: 30s
retries: 5
start_period: 20s
test:
- CMD-SHELL
- pg_isready -d $${POSTGRES_DB} -U $${POSTGRES_USER}
timeout: 5s
image: docker.io/library/postgres:16-alpine
restart: unless-stopped
volumes:
- database:/var/lib/postgresql/data
server:
command: server
depends_on:
postgresql:
condition: service_healthy
env_file:
- .env
environment:
AUTHENTIK_POSTGRESQLHOST: postgresql
AUTHENTIK_POSTGRESQLNAME: ${PG_DB:-authentik}
AUTHENTIK_POSTGRESQLPASSWORD: ${PG_PASS}
AUTHENTIK_POSTGRESQLUSER: ${PG_USER:-authentik}
AUTHENTIK_SECRET_KEY: ${AUTHENTIK_SECRET_KEY:?secret key required}
image: ${AUTHENTIK_IMAGE:-ghcr.io/goauthentik/server}:${AUTHENTIK_TAG:-2026.5.3}
ports:
- ${COMPOSE_PORT_HTTP:-9000}:9000
- ${COMPOSE_PORT_HTTPS:-9443}:9443
restart: unless-stopped
shm_size: 512mb
volumes:
- ./data:/data
- ./custom-templates:/templates
worker:
command: worker
depends_on:
postgresql:
condition: service_healthy
env_file:
- .env
environment:
AUTHENTIK_POSTGRESQLHOST: postgresql
AUTHENTIK_POSTGRESQLNAME: ${PG_DB:-authentik}
AUTHENTIK_POSTGRESQLPASSWORD: ${PG_PASS}
AUTHENTIK_POSTGRESQLUSER: ${PG_USER:-authentik}
AUTHENTIK_SECRET_KEY: ${AUTHENTIK_SECRET_KEY:?secret key required}
image: ${AUTHENTIK_IMAGE:-ghcr.io/goauthentik/server}:${AUTHENTIK_TAG:-2026.5.3}
restart: unless-stopped
shm_size: 512mb
user: root
volumes:
- /var/run/docker.sock:/var/run/docker.sock
- ./data:/data
- ./certs:/certs
- ./custom-templates:/templates
volumes:
database:
driver: local


Générer les clés et les mettre dans le fichier .env:
PASS: openssl rand -base64 36
KEY: openssl rand -base64 60

PG_PASS=<PASS>
AUTHENTIK_SECRET_KEY⇒KEY>
AUTHENTIK_ERROR_REPORTINGENABLED=true
#COMPOSE_PORT_HTTP=80
#COMPOSE_PORT_HTTPS=443
# SMTP server
AUTHENTIK_EMAILHOST=mail.informaniak.com
AUTHENTIK_EMAILPORT=587
# Optionally authenticate (don't add quotation marks to your password)
AUTHENTIK_EMAILUSERNAME=<EMAIL>
AUTHENTIK_EMAILPASSWORD=<PASSWORD>
# STARTTLS / explicit TLS, usually on port 587
AUTHENTIK_EMAILUSE_TLS=true
# Implicit TLS/SSL on the SMTP connection (`USE_SSL` is the variable name), usually on port 465
AUTHENTIK_EMAILUSE_SSL=false
AUTHENTIK_EMAILTIMEOUT=10
# Sender email address; verify that the domain is valid.
AUTHENTIK_EMAIL__FROM=<EMAIL>


Démarrer le container: sudo docker compose up -d
Celà met du temps à charger les container et initialiser la première fois.

Aller sur http:/ /<adresse_ip>:9000 et créer le compte administrateur akadmin avec une adresse e-mail et mot de passe.
Aller dans l'interface administrateur, Répertoire, Utilisateurs
Créer un utilisateur adm_xx, lui donner un mot de passe, puis l'insérer dans le groupe “authentik Admins”.
Tester le nouvel utilisateur.
Désactiver le compte akadmin.

sudo nano /etc/network/interfaces
sudo nano nano /etc/hostname
sudo nano nano /etc/hosts
https://www.it-connect.fr/comment-configurer-une-adresse-ip-fixe-sur-debian-11/

adduser <nom d'utilisateur>

su - <nom d'utilisateur>