Développeur full-stack & ingénieur DevOps freelance

Actix-Web (Rust)

Actix-Web est un framework web Rust ultra-rapide et moderne, reconnu comme l'un des plus performants pour créer des API REST et des microservices.

Pourquoi Actix-Web ?
• Performance extrême : Rust garantit sécurité mémoire et rapidité native
• Asynchrone : gestion efficace de milliers de connexions simultanées
• Type-safe : détection des erreurs à la compilation, zéro runtime error
• Écosystème riche : middleware, WebSocket, HTTP/2, TLS

Exemple : API REST simple

use actix_web::{get, post, web, App, HttpResponse, HttpServer, Responder};
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
struct User {
    id: u32,
    name: String,
    email: String,
}

// Route GET pour récupérer un utilisateur
#[get("/users/{id}")]
async fn get_user(id: web::Path<u32>) -> impl Responder {
    let user = User {
        id: *id,
        name: "John Doe".to_string(),
        email: "john@example.com".to_string(),
    };
    HttpResponse::Ok().json(user)
}

// Route POST pour créer un utilisateur
#[post("/users")]
async fn create_user(user: web::Json<User>) -> impl Responder {
    HttpResponse::Created().json(user.into_inner())
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .service(get_user)
            .service(create_user)
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Vulgarisation : Ce code crée une API REST avec deux endpoints. Le premier (/users/1) retourne un utilisateur en JSON, le second (/users) permet de créer un utilisateur. Actix-Web gère automatiquement la sérialisation JSON grâce à Serde.

SQL (Structured Query Language)

SQL est le langage universel pour interagir avec les bases de données relationnelles. Maîtriser SQL est essentiel pour tout développeur backend, permettant de manipuler efficacement les données.

Pourquoi SQL ?
• Standard universel : fonctionne sur MySQL, PostgreSQL, SQLite, etc.
• Déclaratif : décrit ce qu'on veut, pas comment l'obtenir
• Optimisé : moteurs de requêtes ultra-performants
• Transactions ACID : garantit la cohérence des données

Exemple : Requêtes avancées avec JOIN et agrégats

-- Créer une structure de base
CREATE TABLE users (
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    role_id INT,
    INDEX idx_email (email),
    FOREIGN KEY (role_id) REFERENCES roles(id)
);

CREATE TABLE orders (
    id INT PRIMARY KEY AUTO_INCREMENT,
    user_id INT NOT NULL,
    total DECIMAL(10, 2) NOT NULL,
    status ENUM('pending', 'completed', 'cancelled') DEFAULT 'pending',
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
);

-- Requête complexe : statistiques par utilisateur
SELECT 
    u.name,
    u.email,
    COUNT(o.id) AS total_orders,
    SUM(o.total) AS total_spent,
    AVG(o.total) AS avg_order_value,
    MAX(o.created_at) AS last_order_date
FROM users u
LEFT JOIN orders o ON u.id = o.user_id
WHERE o.status = 'completed'
GROUP BY u.id, u.name, u.email
HAVING total_spent > 100
ORDER BY total_spent DESC
LIMIT 10;

-- Transaction sécurisée
START TRANSACTION;

UPDATE users 
SET name = 'John Updated' 
WHERE id = 1;

INSERT INTO orders (user_id, total, status) 
VALUES (1, 99.99, 'completed');

-- Rollback si erreur, sinon Commit
COMMIT;

-- CTE (Common Table Expression) pour requêtes complexes
WITH monthly_sales AS (
    SELECT 
        DATE_FORMAT(created_at, '%Y-%m') AS month,
        SUM(total) AS monthly_total
    FROM orders
    WHERE status = 'completed'
    GROUP BY month
)
SELECT 
    month,
    monthly_total,
    LAG(monthly_total) OVER (ORDER BY month) AS previous_month,
    monthly_total - LAG(monthly_total) OVER (ORDER BY month) AS growth
FROM monthly_sales
ORDER BY month DESC;

Vulgarisation : SQL permet de manipuler des données de manière déclarative. Le LEFT JOIN récupère tous les utilisateurs même sans commandes. GROUP BY agrège les résultats, HAVING filtre après agrégation. Les transactions garantissent que toutes les opérations réussissent ou échouent ensemble (principe ACID). Les CTE (WITH) permettent de créer des requêtes temporaires réutilisables pour des analyses complexes.

Bonus : Optimisation et index

-- Créer des index pour accélérer les requêtes
CREATE INDEX idx_user_email ON users(email);
CREATE INDEX idx_order_status ON orders(status, created_at);

-- Index composite pour recherches fréquentes
CREATE INDEX idx_user_role_created ON users(role_id, created_at);

-- Analyser les performances
EXPLAIN SELECT * FROM users 
WHERE email = 'john@example.com';

-- Vue pour simplifier les requêtes complexes
CREATE VIEW user_orders_summary AS
SELECT 
    u.id,
    u.name,
    u.email,
    COUNT(o.id) AS order_count,
    SUM(o.total) AS total_revenue
FROM users u
LEFT JOIN orders o ON u.id = o.user_id
GROUP BY u.id, u.name, u.email;

-- Utiliser la vue
SELECT * FROM user_orders_summary 
WHERE total_revenue > 500;

SvelteKit

SvelteKit est le framework full-stack officiel de Svelte, combinant SSR (Server-Side Rendering), SSG (Static Site Generation) et la puissance de Svelte pour créer des applications web modernes et performantes.

Pourquoi SvelteKit ?
• Rendu hybride : SSR, SSG, ou CSR selon vos besoins
• Routing file-based : structure intuitive basée sur les fichiers
• API routes : créez des endpoints backend directement dans votre app
• Adaptateurs : déployez sur Vercel, Netlify, Node, Docker...

Exemple : Page SSR avec chargement de données

// src/routes/users/[id]/+page.server.js
export async function load({ params, fetch }) {
  // Exécuté côté serveur
  const response = await fetch(`https://api.example.com/users/${params.id}`);
  const user = await response.json();

  return {
    user
  };
}

// src/routes/users/[id]/+page.svelte
<script>
  export let data;

  // Les données sont déjà chargées côté serveur
  $: ({ user } = data);
</script>

<style>
  .user-card {
    max-width: 600px;
    margin: 2rem auto;
    padding: 2rem;
    border: 1px solid #ddd;
    border-radius: 8px;
  }
</style>

<div class="user-card">
  <h1>{user.name}</h1>
  <p>Email: {user.email}</p>
  <p>ID: {user.id}</p>
</div>

<!-- src/routes/api/users/+server.js -->
<!-- Créer une API REST directement dans SvelteKit -->
import { json } from '@sveltejs/kit';

export async function GET({ url }) {
  const users = [
    { id: 1, name: 'John', email: 'john@example.com' },
    { id: 2, name: 'Jane', email: 'jane@example.com' }
  ];

  return json(users);
}

export async function POST({ request }) {
  const user = await request.json();
  // Logique de création...

  return json(user, { status: 201 });
}

Vulgarisation : La fonction load() s'exécute côté serveur avant le rendu de la page. Le HTML est généré avec les données déjà présentes, excellent pour le SEO ! Les routes +server.js permettent de créer des API REST directement dans votre app Svelte, sans serveur séparé.

Phalcon (PHP)

Phalcon est un framework PHP full-stack unique : écrit en C et livré comme extension PHP, il offre des performances exceptionnelles tout en conservant la simplicité de PHP.

Pourquoi Phalcon ?
• Vitesse native : écrit en C, Phalcon est le framework PHP le plus rapide
• Faible empreinte mémoire : chargé comme extension, pas de parsing de fichiers
• Full-stack : ORM, templating, routing, validation, cache intégrés
• PSR compatible : suit les standards PHP modernes

Exemple : Contrôleur REST avec ORM

<?php
use Phalcon\Mvc\Controller;
use Phalcon\Http\Response;

class UsersController extends Controller
{
    // GET /users/{id}
    public function getAction($id)
    {
        $user = Users::findFirst([
            'conditions' => 'id = :id:',
            'bind' => ['id' => $id]
        ]);

        if (!$user) {
            return $this->response->setJsonContent([
                'status' => 'error',
                'message' => 'User not found'
            ])->setStatusCode(404);
        }

        return $this->response->setJsonContent([
            'status' => 'success',
            'data' => [
                'id' => $user->id,
                'name' => $user->name,
                'email' => $user->email
            ]
        ]);
    }

    // POST /users
    public function createAction()
    {
        $user = new Users();
        $user->name = $this->request->getPost('name');
        $user->email = $this->request->getPost('email');

        if ($user->save()) {
            return $this->response->setJsonContent([
                'status' => 'success',
                'data' => $user
            ])->setStatusCode(201);
        }

        return $this->response->setJsonContent([
            'status' => 'error',
            'messages' => $user->getMessages()
        ])->setStatusCode(400);
    }
}

Vulgarisation : Phalcon intègre un ORM puissant qui simplifie l'accès aux données. Users::findFirst() génère automatiquement la requête SQL sécurisée. La validation des données se fait dans le modèle, garantissant l'intégrité des données.

Laravel (PHP)

Laravel est le framework PHP de référence : Eloquent pour les données, Blade pour les vues, files d'attente, planificateur, Sanctum pour l'authentification d'API, et des conventions qui rendent un projet lisible par n'importe quel développeur PHP dès le premier jour.

Pourquoi Laravel ?
• Productivité : migrations, validation, tâches de fond et tests livrés d'origine
• Écosystème : Horizon, Octane, Forge, Pest ; une réponse éprouvée à chaque besoin
• Performance : Octane (FrankenPHP, Swoole) garde l'application chargée en mémoire
• Pérennité : versions annuelles, communauté et recrutement faciles

Exemple : API REST avec Form Request et Resource

<?php
// routes/api.php
Route::apiResource('users', UserController::class)->only(['show', 'store']);

// app/Http/Requests/StoreUserRequest.php : la validation vit ici, pas dans le contrôleur
class StoreUserRequest extends FormRequest
{
    public function rules(): array
    {
        return [
            'name'  => ['required', 'string', 'max:100'],
            'email' => ['required', 'email', 'unique:users'],
        ];
    }
}

// app/Http/Controllers/Api/UserController.php
class UserController extends Controller
{
    // GET /api/users/{user} — liaison de modèle implicite : 404 automatique
    public function show(User $user): UserResource
    {
        return new UserResource($user);
    }

    // POST /api/users — $request->validated() ne contient que les champs autorisés
    public function store(StoreUserRequest $request): JsonResponse
    {
        $user = User::create($request->validated());

        return UserResource::make($user)
            ->response()
            ->setStatusCode(201);
    }
}

Vulgarisation : Laravel impose une place à chaque chose. La validation est déclarée dans une classe dédiée, le contrôleur ne fait que relier la requête au modèle, et la Resource décide de ce qui sort en JSON. Un nouveau développeur sait où chercher sans lire toute l'application.

Bash (Bourne Again Shell)

Bash est le shell par défaut sur la plupart des systèmes Linux/Unix. C'est un outil indispensable pour l'automatisation, le déploiement, et l'administration système.

Pourquoi Bash ?
• Omniprésent : disponible sur tous les systèmes Unix/Linux
• Puissant : manipule fichiers, processus, et réseaux
• Automatisation : scripts pour CI/CD, déploiement, monitoring
• Pipeline : chaînage de commandes avec pipes |

Exemple : Script de déploiement automatisé

#!/bin/bash
set -euo pipefail  # Exit on error, undefined vars, pipe failures

# Variables de configuration
APP_NAME="veloce-digital"
DEPLOY_DIR="/var/www/${APP_NAME}"
BACKUP_DIR="/var/backups/${APP_NAME}"
LOG_FILE="/var/log/${APP_NAME}/deploy.log"

# Fonction de logging
log() {
    echo "[$(date +'%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOG_FILE"
}

# Fonction de backup
backup_current() {
    local backup_file="${BACKUP_DIR}/backup_$(date +'%Y%m%d_%H%M%S').tar.gz"
    log "📦 Création du backup: $backup_file"
    
    if [ -d "$DEPLOY_DIR" ]; then
        tar -czf "$backup_file" -C "$DEPLOY_DIR" . 2>>"$LOG_FILE"
        log "✅ Backup créé avec succès"
    else
        log "⚠️  Aucun dossier à sauvegarder"
    fi
}

# Fonction de build
build_app() {
    log "🔨 Compilation de l'application..."
    
    cargo build --release 2>>"$LOG_FILE" || {
        log "❌ Erreur de compilation"
        return 1
    }
    
    log "✅ Compilation réussie"
}

# Fonction de déploiement
deploy_app() {
    log "🚀 Déploiement en cours..."
    
    # Arrêt du service
    sudo systemctl stop "${APP_NAME}.service" 2>>"$LOG_FILE" || true
    
    # Copie des binaires
    sudo cp target/release/"${APP_NAME}" "$DEPLOY_DIR/" || {
        log "❌ Erreur de copie des fichiers"
        return 1
    }
    
    # Copie des assets
    sudo rsync -av --delete static/ "${DEPLOY_DIR}/static/" 2>>"$LOG_FILE"
    
    # Redémarrage du service
    sudo systemctl start "${APP_NAME}.service" 2>>"$LOG_FILE"
    
    # Vérification du statut
    if sudo systemctl is-active --quiet "${APP_NAME}.service"; then
        log "✅ Déploiement réussi - Service actif"
    else
        log "❌ Le service n'a pas démarré correctement"
        return 1
    fi
}

# Script principal
main() {
    log "🎯 Début du déploiement de ${APP_NAME}"
    
    # Création des dossiers si nécessaire
    mkdir -p "$BACKUP_DIR" "$(dirname "$LOG_FILE")"
    
    # Backup avant déploiement
    backup_current || {
        log "⚠️  Backup échoué, mais on continue..."
    }
    
    # Build et déploiement
    if build_app && deploy_app; then
        log "🎉 Déploiement terminé avec succès"
        exit 0
    else
        log "💥 Déploiement échoué - Restauration du backup"
        # Logique de rollback ici
        exit 1
    fi
}

# Exécution
main "$@"

Vulgarisation : Ce script de déploiement automatise toutes les étapes critiques : backup avant modification, compilation, arrêt du service, copie des fichiers, redémarrage, et vérification. set -euo pipefail rend le script robuste en arrêtant l'exécution à la première erreur. Les fonctions permettent de structurer le code et de faciliter la maintenance.

Bonus : Manipulation de fichiers et pipes

# Recherche et traitement de fichiers
find /var/log -name "*.log" -mtime +30 -exec gzip {} \;

# Pipeline complexe : analyse de logs
grep "ERROR" /var/log/app.log | \
    awk '{print $1, $2, $NF}' | \
    sort | uniq -c | sort -nr | head -10

# Boucle sur des fichiers
for file in *.txt; do
    echo "Traitement de $file"
    sed -i 's/ancien/nouveau/g' "$file"
done

# Conditions et tests
if [ -f ".env" ] && [ -r ".env" ]; then
    source .env
    echo "Configuration chargée"
else
    echo "Fichier .env manquant ou illisible" >&2
    exit 1
fi

# Traitement parallèle avec xargs
ls *.jpg | xargs -P 4 -I {} convert {} -resize 800x600 resized_{}

# Monitoring avec watch
watch -n 5 'systemctl status veloce-digital | grep "Active:"'

nftables - Pare-feu Linux

nftables est le pare-feu du noyau Linux depuis 2019 ; iptables n'est plus qu'une couche de compatibilité par-dessus. Une seule syntaxe pour IPv4 et IPv6, des ensembles dynamiques, et un rechargement atomique : les règles s'appliquent d'un bloc, sans fenêtre où le serveur est à nu.

Fonctionnalités clés :
• Filtrage par IP/port : IPv4 et IPv6 dans la même table
• NAT : translation d'adresses réseau
• Stateful inspection : suivi des connexions (conntrack)
• Rate limiting : ensembles dynamiques avec expiration, sans outil tiers
• Rechargement atomique : tout passe, ou rien ne change

Exemple : /etc/nftables.conf d'un serveur web

#!/usr/sbin/nft -f
# Politique par défaut : tout refuser en entrée

flush ruleset

table inet filter {
    # Adresses ayant trop insisté sur SSH (expirent d'elles-mêmes)
    set ssh_bruteforce {
        type ipv4_addr
        flags dynamic, timeout
        timeout 10m
    }

    chain input {
        type filter hook input priority 0; policy drop;

        # Loopback, connexions établies, paquets invalides
        iif lo accept
        ct state established,related accept
        ct state invalid drop

        # SSH : au-delà de 4 tentatives par minute, l'adresse est mise de côté
        tcp dport 22 ct state new ip saddr @ssh_bruteforce drop
        tcp dport 22 ct state new add @ssh_bruteforce { ip saddr limit rate over 4/minute } drop
        tcp dport 22 accept

        # HTTP et HTTPS
        tcp dport { 80, 443 } accept

        # Protection SYN flood
        tcp flags syn limit rate 25/second burst 50 packets accept

        # ICMP utile (PMTU, voisinage IPv6)
        icmp type echo-request limit rate 5/second accept
        icmpv6 type { nd-neighbor-solicit, nd-neighbor-advert, nd-router-advert, echo-request } accept

        # Journal des rejets, sans inonder
        limit rate 5/minute log prefix "nft_input_denied: " level debug
    }

    chain forward {
        type filter hook forward priority 0; policy drop;
    }

    chain output {
        type filter hook output priority 0; policy accept;
    }
}

# Vérifier puis activer :
#   nft -c -f /etc/nftables.conf
#   systemctl enable --now nftables

Vulgarisation : nftables agit comme un garde à l'entrée de votre serveur. Les chaînes définissent qui peut entrer (input), traverser (forward) ou sortir (output). L'ensemble dynamique met de côté pendant dix minutes toute adresse qui insiste trop sur SSH, sans fail2ban ni script. Et comme le fichier se recharge d'un bloc, une faute de frappe ne laisse jamais le serveur sans règles.

Packet Filter (pf) - Pare-feu BSD

pf est le pare-feu d'OpenBSD, réputé pour sa syntaxe claire, sa performance et sa sécurité renforcée. Utilisé sur BSD et macOS.

Avantages de pf :
• Syntaxe lisible : configuration plus intuitive qu'iptables
• Performance : optimisé pour les hautes charges
• Intégré : natif sur OpenBSD, FreeBSD, macOS
• Tables dynamiques : listes noires automatiques

Exemple : Configuration /etc/pf.conf

# Macros pour faciliter la maintenance
ext_if = "em0"
int_if = "em1"
webserver = "192.168.1.100"
ssh_port = "22"
allowed_ssh = "{ 203.0.113.0/24 }"

# Tables pour les attaquants
table <bruteforce> persist
table <spammers> persist file "/etc/pf/spammers.txt"

# Options globales
set skip on lo0
set block-policy drop
set loginterface $ext_if

# Scrubbing (normalisation du trafic)
match in all scrub (no-df random-id max-mss 1440)

# NAT pour le réseau interne
match out on $ext_if inet from $int_if:network to any nat-to ($ext_if)

# Politique par défaut
block log all

# Anti-spoofing
antispoof quick for { $ext_if $int_if }

# Autoriser le trafic loopback
pass quick on lo0

# SSH avec protection brute force
pass in on $ext_if proto tcp from $allowed_ssh to any port $ssh_port \
    flags S/SA keep state \
    (max-src-conn 10, max-src-conn-rate 5/30, \
     overload <bruteforce> flush global)

# Bloquer les attaquants identifiés
block drop in quick from <bruteforce>
block drop in quick from <spammers>

# HTTP et HTTPS vers le webserver
pass in on $ext_if proto tcp to $webserver port { 80 443 } \
    flags S/SA synproxy state

# Autoriser le trafic sortant
pass out on $ext_if keep state

# ICMP (ping) avec rate limiting
pass in inet proto icmp all icmp-type echoreq max-pkt-rate 10/s

Vulgarisation : pf utilise une syntaxe plus humaine qu'iptables. Les macros simplifient la configuration. La table <bruteforce> se remplit automatiquement avec les IPs qui dépassent les limites de connexion. synproxy protège contre les attaques SYN flood en validant les connexions avant de les transmettre au serveur.

fail2ban - Protection contre les intrusions

fail2ban analyse les logs en temps réel et bannit les IPs suspectes en créant automatiquement des règles de pare-feu.

Cas d'usage :
• SSH : bloquer les attaques par force brute
• Web : protéger contre les scans et injections SQL
• Mail : limiter les tentatives de spam
• Personnalisable : règles custom pour n'importe quel service

Exemple : Configuration /etc/fail2ban/jail.local

[DEFAULT]
# Durée du bannissement (10 minutes)
bantime = 600
# Période d'observation (10 minutes)
findtime = 600
# Nombre de tentatives avant ban
maxretry = 5
# Action : iptables + email
destemail = admin@veloce.digital
sendername = Fail2Ban
action = %(action_mwl)s

# Protection SSH
[sshd]
enabled = true
port = ssh
filter = sshd
logpath = /var/log/auth.log
maxretry = 3
bantime = 3600

# Protection Nginx (attaques web)
[nginx-http-auth]
enabled = true
filter = nginx-http-auth
logpath = /var/log/nginx/error.log
maxretry = 3

[nginx-noscript]
enabled = true
filter = nginx-noscript
logpath = /var/log/nginx/access.log
maxretry = 6

[nginx-badbots]
enabled = true
filter = nginx-badbots
logpath = /var/log/nginx/access.log
maxretry = 2

[nginx-noproxy]
enabled = true
filter = nginx-noproxy
logpath = /var/log/nginx/access.log
maxretry = 2

# Protection custom pour API
[veloce-api]
enabled = true
filter = veloce-api
logpath = /var/log/veloce-digital/app.log
maxretry = 10
findtime = 300
bantime = 7200

Filtre custom : /etc/fail2ban/filter.d/veloce-api.conf

[Definition]
# Détecter les tentatives de force brute sur l'API
failregex = ^.*"client_ip":"<HOST>".*"status":401.*$
            ^.*"client_ip":"<HOST>".*"error":"Invalid CSRF token".*$
            ^.*Rate limit exceeded.*from <HOST>.*$

ignoreregex =

Vulgarisation : fail2ban surveille les logs comme un gardien. Si une IP échoue 3 fois à se connecter en SSH en 10 minutes, elle est bannie 1 heure. Les filtres custom permettent de protéger vos propres applications en analysant leurs logs.

systemd - Gestionnaire de services

systemd est le système d'init moderne de Linux, gérant les services, les montages, les timers, et bien plus.

Avantages :
• Démarrage parallèle : boot rapide
• Gestion de dépendances : ordre de démarrage automatique
• Redémarrage auto : relance les services crashés
• Journalisation : logs centralisés avec journalctl

Exemple : Service systemd complet

# /etc/systemd/system/veloce-digital.service
[Unit]
Description=Veloce Digital - Actix-web Application
Documentation=https://veloce.digital/docs
After=network.target mysql.service
Requires=mysql.service
Wants=redis.service

[Service]
Type=simple
User=veloce
Group=veloce
WorkingDirectory=/var/www/veloce-digital

# Variables d'environnement
Environment="RUN_MODE=prod"
Environment="RUST_LOG=info"
EnvironmentFile=/etc/veloce-digital/production.env

# Commande de démarrage
ExecStart=/var/www/veloce-digital/veloce-digital

# Redémarrage automatique en cas de crash
Restart=always
RestartSec=5s

# Limites de sécurité
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=strict
ProtectHome=true
ReadWritePaths=/var/log/veloce-digital /var/lib/veloce-digital

# Limites de ressources
LimitNOFILE=65536
MemoryLimit=2G
CPUQuota=80%

# Notifications
StandardOutput=journal
StandardError=journal
SyslogIdentifier=veloce-digital

[Install]
WantedBy=multi-user.target

Commandes essentielles :

# Gestion du service
sudo systemctl start veloce-digital
sudo systemctl stop veloce-digital
sudo systemctl restart veloce-digital
sudo systemctl reload veloce-digital  # Recharge config sans coupure
sudo systemctl status veloce-digital

# Activer au démarrage
sudo systemctl enable veloce-digital

# Logs en temps réel
sudo journalctl -u veloce-digital -f

# Logs des dernières 24h
sudo journalctl -u veloce-digital --since "24 hours ago"

# Logs avec niveau de priorité
sudo journalctl -u veloce-digital -p err

# Timer systemd (équivalent de cron)
# /etc/systemd/system/backup.timer
[Unit]
Description=Daily Backup Timer

[Timer]
OnCalendar=daily
OnCalendar=02:00
Persistent=true

[Install]
WantedBy=timers.target

Vulgarisation : systemd gère le cycle de vie des services. Restart=always relance automatiquement l'application si elle crash. Les directives de sécurité (ProtectSystem, NoNewPrivileges) isolent le service pour limiter les dégâts en cas de compromission. Les timers remplacent avantageusement cron.

CrowdSec - Sécurité collaborative

CrowdSec est un système IPS (Intrusion Prevention System) moderne qui combine analyse comportementale et intelligence collective.

Innovation :
• Crowd-sourcing : partage des menaces entre utilisateurs
• Machine Learning : détection des comportements suspects
• Bouncers : intégration iptables, nginx, cloudflare
• Open Source : alternative moderne à fail2ban

Exemple : Installation et configuration

# Installation
curl -s https://packagecloud.io/install/repositories/crowdsec/crowdsec/script.deb.sh | sudo bash
sudo apt install crowdsec

# Installation du bouncer iptables
sudo apt install crowdsec-firewall-bouncer-iptables

# Configuration : /etc/crowdsec/config.yaml
common:
  daemonize: true
  pid_dir: /var/run/
  log_media: file
  log_level: info
  log_dir: /var/log/
  working_dir: .

config_paths:
  config_dir: /etc/crowdsec/
  data_dir: /var/lib/crowdsec/data/
  simulation_path: /etc/crowdsec/simulation.yaml
  hub_dir: /etc/crowdsec/hub/
  index_path: /etc/crowdsec/hub/.index.json

api:
  client:
    credentials_path: /etc/crowdsec/local_api_credentials.yaml
  server:
    listen_uri: 127.0.0.1:8080
    profiles_path: /etc/crowdsec/profiles.yaml

crowdsec_service:
  acquisition_path: /etc/crowdsec/acquis.yaml
  parser_routines: 1

Configuration des sources : /etc/crowdsec/acquis.yaml

filenames:
  - /var/log/nginx/access.log
  - /var/log/nginx/error.log
labels:
  type: nginx

---
filenames:
  - /var/log/auth.log
labels:
  type: syslog

---
filenames:
  - /var/log/veloce-digital/app.log
labels:
  type: veloce-api

Commandes utiles :

# Voir les décisions actives (IPs bannies)
sudo cscli decisions list

# Bannir manuellement une IP
sudo cscli decisions add --ip 192.168.1.100 --duration 4h --reason "Manual ban"

# Débannir une IP
sudo cscli decisions delete --ip 192.168.1.100

# Installer des scénarios (collections)
sudo cscli collections install crowdsecurity/nginx
sudo cscli collections install crowdsecurity/linux
sudo cscli collections install crowdsecurity/sshd

# Voir les alertes
sudo cscli alerts list

# Statistiques
sudo cscli metrics

Vulgarisation : CrowdSec analyse vos logs comme fail2ban, mais ajoute l'intelligence collective : si un attaquant est détecté chez un utilisateur, tous les autres sont protégés. Les "bouncers" appliquent les décisions de bannissement sur vos pare-feu, serveurs web, ou CDN.

Docker - Containerisation

Docker permet d'empaqueter des applications avec toutes leurs dépendances dans des conteneurs légers et portables.

Avantages :
• Isolation : chaque app dans son environnement
• Portabilité : "works on my machine" devient réalité
• Légèreté : plus rapide que les VMs
• Scalabilité : orchestration avec Docker Compose/Kubernetes

Exemple : Dockerfile multi-stage pour Rust

# Stage 1: Build
FROM rust:1.75-slim AS builder

WORKDIR /build

# Copier les manifestes et créer un build de dépendances
COPY Cargo.toml Cargo.lock ./
RUN mkdir src && \
    echo "fn main() {}" > src/main.rs && \
    cargo build --release && \
    rm -rf src

# Copier le code source et build final
COPY . .
RUN touch src/main.rs && \
    cargo build --release

# Stage 2: Runtime
FROM debian:bookworm-slim

# Installer les dépendances runtime
RUN apt-get update && \
    apt-get install -y ca-certificates libssl3 && \
    rm -rf /var/lib/apt/lists/*

# Créer un utilisateur non-root
RUN useradd -m -u 1000 veloce && \
    mkdir -p /app/static /app/templates && \
    chown -R veloce:veloce /app

WORKDIR /app
USER veloce

# Copier le binaire depuis le builder
COPY --from=builder /build/target/release/veloce-digital .
COPY --chown=veloce:veloce static ./static
COPY --chown=veloce:veloce templates ./templates

ENV RUN_MODE=prod
ENV RUST_LOG=info

EXPOSE 8080

HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
    CMD curl -f http://localhost:8080/health || exit 1

CMD ["./veloce-digital"]

Docker Compose : docker-compose.yml

version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: veloce-digital
    restart: unless-stopped
    ports:
      - "8080:8080"
    environment:
      - DATABASE_URL=mysql://user:pass@db:3306/veloce
      - REDIS_URL=redis://redis:6379
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_started
    networks:
      - veloce-network
    volumes:
      - ./logs:/app/logs

  db:
    image: mysql:8.0
    container_name: veloce-db
    restart: unless-stopped
    environment:
      - MYSQL_ROOT_PASSWORD=root_password
      - MYSQL_DATABASE=veloce
      - MYSQL_USER=user
      - MYSQL_PASSWORD=pass
    volumes:
      - db-data:/var/lib/mysql
      - ./migrations:/docker-entrypoint-initdb.d
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - veloce-network

  redis:
    image: redis:7-alpine
    container_name: veloce-redis
    restart: unless-stopped
    command: redis-server --appendonly yes
    volumes:
      - redis-data:/data
    networks:
      - veloce-network

  nginx:
    image: nginx:alpine
    container_name: veloce-nginx
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
      - ./ssl:/etc/nginx/ssl:ro
    depends_on:
      - app
    networks:
      - veloce-network

volumes:
  db-data:
  redis-data:

networks:
  veloce-network:
    driver: bridge

Vulgarisation : Docker crée des conteneurs légers qui embarquent l'application et ses dépendances. Le build multi-stage optimise la taille : on compile dans une image lourde, puis on copie uniquement le binaire dans une image légère. Docker Compose orchestre plusieurs conteneurs qui communiquent via un réseau privé.

Podman - Conteneurs sans daemon

Podman est une alternative à Docker qui s'exécute sans démon root, offrant une isolation de sécurité supérieure grâce aux conteneurs rootless.

Avantages clés :
• Rootless : conteneurs sans privilèges root — attaque latérale impossible
• Sans daemon : pas de service système permanent, moins de surface d'attaque
• Compatible Docker : mêmes commandes, mêmes Dockerfiles, même registre
• Pods : grouper plusieurs conteneurs (concept Kubernetes natif)

Exemple : build et run rootless

# Pas de `sudo` requis
podman build -t veloce-digital:latest .
podman run -d --name veloce \
    -p 8080:8080 \
    -e RUN_MODE=prod \
    veloce-digital:latest

# Vérifier le conteneur
podman ps
podman logs veloce

# Générer un unit systemd pour démarrage auto (rootless)
podman generate systemd --name veloce --files --new
mv container-veloce.service ~/.config/systemd/user/
systemctl --user enable --now container-veloce.service

# Pod multi-conteneurs (app + db)
podman pod create --name veloce-pod -p 8080:8080 -p 3306:3306
podman run -d --pod veloce-pod --name db \
    -e MYSQL_ROOT_PASSWORD=secret mysql:8.0
podman run -d --pod veloce-pod --name app \
    -e DATABASE_URL=mysql://root:secret@127.0.0.1/veloce \
    veloce-digital:latest

Vulgarisation : Podman fait la même chose que Docker (conteneurs, images, Compose) mais sans daemon root tournant en permanence. Un conteneur compromis ne peut pas escalader vers root sur l'hôte — idéal en production sur serveurs Linux.

Jails FreeBSD - Isolation native

Les Jails FreeBSD sont la technologie d'isolation native du noyau FreeBSD, antérieure aux conteneurs Linux, offrant une séparation stricte sans overhead de virtualisation.

Points forts :
• Isolation complète : filesystem, réseau, utilisateurs cloisonnés au niveau noyau
• Sécurité : un processus en jail ne peut pas accéder à l'hôte ni aux autres jails
• Légèreté : aucune émulation, partage direct du noyau, démarrage en millisecondes
• VNET : stack réseau virtualisée indépendante par jail

Exemple : création et gestion

# Créer un dataset ZFS pour la jail
zfs create -p zroot/jails/veloce

# Extraire le userland FreeBSD
bsdinstall jail /jails/veloce

# Configurer /etc/jail.conf
cat > /etc/jail.conf << 'EOF'
veloce {
    host.hostname = "veloce.local";
    ip4.addr = "lo1|10.10.0.2/24";
    interface = "lo1";
    path = "/jails/veloce";
    exec.start = "/bin/sh /etc/rc";
    exec.stop  = "/bin/sh /etc/rc.shutdown jail";
    mount.devfs;
    allow.raw_sockets;
    persist;
}
EOF

# Démarrer la jail
service jail start veloce

# Entrer dans la jail
jexec veloce /bin/sh

# Depuis l'intérieur : installer l'app
pkg install -y rust

# Lister les jails actives
jls -v

Vulgarisation : Les jails BSD sont les ancêtres des conteneurs Docker, mais intégrées directement dans le noyau FreeBSD. Elles offrent une isolation réelle sans daemon externe — chaque jail a son propre réseau, ses processus, ses utilisateurs, totalement séparés de l'hôte.

Bastille BSD - Gestionnaire de Jails

Bastille est le gestionnaire de jails FreeBSD de référence : il automatise la création, la mise à jour, la mise en réseau et le déploiement de jails via des templates déclaratifs.

Fonctionnalités clés :
• Templates : décrire une jail comme un Dockerfile (Bastillefile)
• ZFS natif : clones et snapshots pour déploiements instantanés
• Réseau VNET : chaque jail avec sa propre interface virtuelle
• Mise à jour : bastille update pour patcher toutes les jails en une commande

Exemple : déployer une app Rust via Bastille

# Installer Bastille
pkg install -y bastille

# Télécharger un release FreeBSD (base de toutes les jails)
bastille bootstrap 14.3-RELEASE update

# Créer une jail thin (clone ZFS léger)
bastille create veloce 14.3-RELEASE 10.10.0.10/24 em0

# Démarrer
bastille start veloce

# Installer Rust et l'app
bastille pkg veloce install -y rust
bastille cmd veloce cargo install veloce-digital

# Bastillefile (template déclaratif)
cat > Bastillefile << 'EOF'
PKG rust curl
CMD cargo install veloce-digital
SYSRC veloce_enable=YES
SERVICE veloce start
EOF

# Appliquer le template à une jail
bastille template veloce ./Bastillefile

# Snapshot avant mise à jour
bastille snapshot veloce
bastille update veloce

# Lister toutes les jails
bastille list

Vulgarisation : Bastille est à FreeBSD ce que Docker Compose est à Linux : il orchestre les jails via des fichiers déclaratifs (Bastillefile) et exploite ZFS pour des clones instantanés. Un déploiement complet prend quelques secondes grâce à la légèreté des jails.

Git - Gestion de versions

Git est le système de contrôle de version décentralisé standard, essentiel pour tout projet de développement moderne.

Fonctionnalités clés :
• Branches : développement parallèle sans conflit
• Historique : traçabilité complète des modifications
• Collaboration : travail d'équipe efficace
• Workflow : GitFlow, GitHub Flow, trunk-based

Exemple : Workflow professionnel

# Configuration initiale
git config --global user.name "John Doe"
git config --global user.email "john@veloce.digital"
git config --global init.defaultBranch main
git config --global pull.rebase true
git config --global core.autocrlf input

# Alias utiles
git config --global alias.st status
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.lg "log --graph --oneline --all --decorate"
git config --global alias.unstage "reset HEAD --"

# Workflow GitFlow
# 1. Créer une branche feature
git checkout -b feature/add-sql-section

# 2. Travail avec commits atomiques
git add templates/index.html
git commit -m "feat: add SQL section to Point Dev

- Add SQL tab with database icon
- Include advanced query examples (CTE, window functions)
- Add optimization tips with EXPLAIN"

# 3. Garder la branche à jour
git fetch origin
git rebase origin/main

# 4. Push et Pull Request
git push -u origin feature/add-sql-section

# 5. Après merge, nettoyage
git checkout main
git pull
git branch -d feature/add-sql-section

# Commandes avancées
# Stash : mettre de côté des modifications
git stash save "WIP: refactoring controller"
git stash list
git stash pop

# Cherry-pick : appliquer un commit spécifique
git cherry-pick abc1234

# Interactive rebase : nettoyer l'historique
git rebase -i HEAD~5

# Bisect : trouver le commit qui a introduit un bug
git bisect start
git bisect bad HEAD
git bisect good v1.2.0
# Git teste automatiquement chaque commit
git bisect reset

# Reflog : récupérer des commits "perdus"
git reflog
git checkout HEAD@{2}

# Submodules : gérer des dépendances Git
git submodule add https://github.com/user/repo.git external/repo
git submodule update --init --recursive

Git Hooks : Automatisation

#!/bin/bash
# .git/hooks/pre-commit
# Vérifications avant chaque commit

set -e

echo "🔍 Running pre-commit checks..."

# Vérifier la compilation
echo "📦 Building project..."
cargo build --all-features || {
    echo "❌ Build failed"
    exit 1
}

# Tests
echo "🧪 Running tests..."
cargo test || {
    echo "❌ Tests failed"
    exit 1
}

# Linter
echo "🔧 Running clippy..."
cargo clippy -- -D warnings || {
    echo "❌ Clippy found issues"
    exit 1
}

# Formatage
echo "✨ Checking formatting..."
cargo fmt -- --check || {
    echo "❌ Code not formatted. Run: cargo fmt"
    exit 1
}

# Vérifier les secrets
echo "🔐 Checking for secrets..."
if git diff --cached | grep -iE "(password|secret|api_key|token)" >/dev/null; then
    echo "⚠️  Warning: Potential secret detected in commit"
    read -p "Continue? (y/n) " -n 1 -r
    echo
    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
        exit 1
    fi
fi

echo "✅ All checks passed!"

Vulgarisation : Git enregistre l'historique complet du projet comme une timeline. Les branches permettent d'expérimenter sans risque. Le rebase nettoie l'historique avant le merge pour garder une timeline lisible. Les hooks automatisent les vérifications pour éviter de commiter du code cassé.