Chapitre 23 : Annexes

Introduction

Ce chapitre regroupe les annexes : glossaire technique, cheat sheets des outils essentiels, et commandes fondamentales pour le développement backend.

---

A. Glossaire Technique (200+ termes)

A

ACID — Atomicité, Cohérence, Isolation, Durabilité. Propriétés garanties par les transactions en base de données relationnelle.

Aggregate — Dans DDD, un groupe d'objets liés traités comme une unité cohérente.

API Gateway — Serveur qui agit comme point d'entrée unique pour un système de microservices, gérant le routage, l'authentification, et le rate limiting.

APM — Application Performance Monitoring. Outils (Datadog, New Relic) qui surveillent les performances des applications.

Async — Asynchrone. Opération qui ne bloque pas le thread appelant.

At-least-once — Garantie de livraison : un message sera livré au moins une fois (possiblement en double).

At-most-once — Garantie de livraison : un message sera livré au plus une fois (possiblement perdu).

B

B-Tree — Arbre équilibré utilisé comme structure d'index dans la plupart des bases de données relationnelles.

Backpressure — Mécanisme de régulation où un consommateur lent signale au producteur de ralentir.

Base64 — Encodage binaire→texte utilisé dans les URLs, JWT tokens.

Bcrypt — Algorithme de hash de mots de passe avec sel intégré et facteur de coût ajustable.

BFF (Backend For Frontend) — Pattern où un backend dédié sert un frontend spécifique (mobile, web).

Blue/Green Deployment — Stratégie de déploiement avec deux environnements identiques (B/G) pour basculer instantanément.

Bounded Context — Concept DDD : frontière explicite autour d'un modèle de domaine.

Broker — Intermédiaire de messagerie (Kafka, RabbitMQ, etc.).

C

Cache Stampede — Phénomène où plusieurs requêtes régénèrent simultanément un cache expiré.

Canary Deployment — Déploiement progressif où un petit pourcentage de trafic va vers la nouvelle version.

CAP Theorem — Théorème de Brewer : Cohérence, Disponibilité, Partition Tolerance : maximum 2/3.

CDN — Content Delivery Network. Réseau de serveurs géo-distribués pour servir du contenu statique.

Circuit Breaker — Pattern de résilience qui arrête les appels vers un service défaillant.

CQRS — Command Query Responsibility Segregation. Séparation des modèles de lecture et d'écriture.

CRDT — Conflict-Free Replicated Data Type. Structure de données qui converge sans conflit.

CRUD — Create, Read, Update, Delete. Opérations de base sur les données.

D

Daemon — Processus qui tourne en arrière-plan (dockerd, kubelet).

Data Lake — Stockage centralisé de données brutes à grande échelle.

Data Warehouse — Base de données optimisée pour l'analyse et le reporting.

DCL — Data Control Language (GRANT, REVOKE).

DDD — Domain-Driven Design. Approche de conception centrée sur le domaine métier.

DDL — Data Definition Language (CREATE, ALTER, DROP).

Dead Letter Queue — Queue où atterrissent les messages qui n'ont pas pu être traités.

Denormalization — Ajout délibéré de redondance pour améliorer les performances en lecture.

Dependency Injection — Pattern où les dépendances sont fournies de l'extérieur plutôt que créées en interne.

Docker — Plateforme de conteneurisation.

DORA — DevOps Research and Assessment. Métriques : déploiement frequency, lead time, MTTR, change failure rate.

DRY — Don't Repeat Yourself. Principe d'éviter la duplication.

DSL — Domain-Specific Language. Langage spécialisé pour un domaine particulier.

DTO — Data Transfer Object. Objet pour transporter des données entre couches.

E

eBPF — Extended Berkeley Packet Filter. Technologie permettant d'exécuter du code sandboxé dans le noyau Linux.

EDA — Event-Driven Architecture. Architecture basée sur les événements.

Elasticsearch — Moteur de recherche distribué basé sur Lucene.

Event Sourcing — Pattern où l'état est stocké comme une séquence d'événements.

Exactly-once — Garantie de livraison : un message sera livré exactement une fois (le plus difficile).

F

FaaS — Function as a Service. Exécution de fonctions serverless.

Feature Flag — Mécanisme pour activer/désactiver des fonctionnalités sans déploiement.

Foreign Key — Contrainte référençant une clé primaire d'une autre table.

G

Garbage Collection — Gestion automatique de la mémoire (V8, JVM).

GIN Index — Generalized Inverted Index. Index PostgreSQL pour full-text search et tableaux.

GitOps — Utilisation de Git comme source de vérité pour l'infrastructure déclarative.

gRPC — Framework RPC haute performance utilisant Protocol Buffers.

Grafana — Plateforme de dashboards et d'alerting.

H

Hashing — Transformation de données en une empreinte de taille fixe.

HCL — HashiCorp Configuration Language. Langage de Terraform.

Head-of-line Blocking — Un appel lent bloque les autres dans la même file.

Health Check — Vérification de l'état d'un service (liveness, readiness).

Helm — Package manager pour Kubernetes.

HPA — Horizontal Pod Autoscaler. Auto-scaling Kubernetes basé sur métriques.

HTTP — HyperText Transfer Protocol. Protocole de communication web.

HTTPS — HTTP over TLS. Version sécurisée de HTTP.

I

IaC — Infrastructure as Code. Gestion de l'infrastructure par code déclaratif.

Idempotence — Propriété où une opération peut être répétée sans effet de bord.

Ingress — Ressource Kubernetes qui expose des routes HTTP/S.

IoC — Inversion of Control. Principe où le contrôle du flux est délégué à un conteneur.

IPVS — IP Virtual Server. Mode de proxy kube-proxy.

Isolation Level — Niveau d'isolation des transactions (Read Uncommitted à Serializable).

J

Jaeger — Tracing distribué open-source.

JOIN — Opération SQL combinant des lignes de plusieurs tables.

JSON — JavaScript Object Notation. Format d'échange de données léger.

JWT — JSON Web Token. Format de token pour l'authentification.

K

Kafka — Plateforme de streaming événementiel distribuée.

kubectl — CLI pour interagir avec Kubernetes.

Kubernetes — Orchestrateur de containers open-source.

L

Latency — Temps de réponse d'une opération. p50, p95, p99, p999.

Load Balancer — Distributeur de trafic entre plusieurs serveurs.

Logging — Enregistrement structuré des événements système.

LSM-Tree — Log-Structured Merge-Tree. Structure de données pour écritures intensives (Cassandra, RocksDB).

M

MapReduce — Paradigme de traitement batch distribué.

Message Broker — Intermédiaire de messagerie asynchrone.

Microservice — Service autonome et indépendamment déployable.

Middleware — Logiciel agissant comme intermédiaire entre applications.

Migration — Versionnement des changements de schéma de base de données.

MTTR — Mean Time To Recovery. Temps moyen de récupération après incident.

MVCC — Multi-Version Concurrency Control. Gestion des accès concurrents par versions.

mTLS — Mutual TLS. Authentification bilatérale par certificats.

N

N+1 Problem — Problème de performance dû à des requêtes supplémentaires inattendues.

Namespace — Isolation logique des ressources (Kubernetes, Linux).

NATS — Message broker haute performance.

Nginx — Serveur web et reverse proxy.

NoSQL — Base de données non relationnelle (document, key-value, graph, column).

O

OAuth2 — Framework d'autorisation standard (RFC 6749).

Observability — Capacité à comprendre l'état interne d'un système via métriques, logs, traces.

OLAP — Online Analytical Processing. Traitement analytique (requêtes lourdes, agrégations).

OLTP — Online Transaction Processing. Traitement transactionnel (requêtes courtes, fréquentes).

OpenAPI — Spécification standard pour les API REST (ex-Swagger).

OpenTelemetry — Framework d'observabilité vendor-neutral.

ORM — Object-Relational Mapping. Abstraction entre objets et tables.

Outbox Pattern — Stocker les événements dans la transaction DB pour garantie.

OWASP — Open Web Application Security Project. Référence sécurité web.

P

P99 — 99ème percentile de latence. Métrique clé pour la performance.

Partitioning — Division d'une table en segments physiques.

Pod — Plus petite unité déployable dans Kubernetes.

PostgreSQL — Base de données relationnelle open-source avancée.

Prometheus — Système de monitoring et alerting.

Protobuf — Protocol Buffers. Format de sérialisation binaire.

Proxy — Intermédiaire réseau.

Q

QPS — Queries Per Second. Métrique de débit.

Queue — Structure de données FIFO pour la gestion de messages.

R

Rate Limiting — Limitation du nombre de requêtes par unité de temps.

Redis — Stockage en mémoire de structures de données.

Replica — Copie redondante d'une base de données (read replica, follower).

Replication — Copie de données entre nœuds pour disponibilité.

REST — Representational State Transfer. Style architectural pour API web.

Rolling Update — Mise à jour progressive d'une application.

S

Saga — Pattern de transaction distribuée avec compensation.

Service Discovery — Mécanisme pour localiser dynamiquement des services.

Service Mesh — Couche d'infrastructure pour la communication inter-services (Istio, Linkerd).

Session — État persistant entre un client et un serveur.

Sharding — Partitionnement horizontal de données sur plusieurs bases.

Singleton — Pattern garantissant une seule instance d'une classe.

SLO — Service Level Objective. Objectif de niveau de service.

SOLID — Principes de programmation orientée objet : SRP, OCP, LSP, ISP, DIP.

SPOF — Single Point of Failure. Point unique de défaillance.

SSL/TLS — Chiffrement de la couche de transport.

Stream — Flux de données continu.

T

TCP — Transmission Control Protocol. Protocole de transport fiable.

Terraform — Outil Infrastructure as Code.

TLS — Transport Layer Security. Successeur de SSL.

Token — Jeton d'authentification (JWT, OAuth).

Topic — Catégorie de messages dans Kafka.

Transaction — Unité logique de travail en base de données.

TTL — Time-To-Live. Durée de vie d'une donnée en cache.

TypeORM — ORM TypeScript pour bases SQL.

U

UDP — User Datagram Protocol. Protocole de transport non fiable.

URL — Uniform Resource Locator.

UUID — Universally Unique Identifier. Identifiant unique universel (128 bits).

V

Vector Clock — Mécanisme pour ordonner les événements dans un système distribué.

Versioning — Gestion des versions (API, schéma, migrations).

Virtual Machine — Machine virtuelle avec OS complet.

VLAN — Virtual Local Area Network. Réseau local virtuel.

Volume — Stockage persistant pour containers.

W

WAL — Write-Ahead Log. Journal de transactions.

WebSocket — Protocole de communication bidirectionnelle.

WAF — Web Application Firewall. Pare-feu applicatif.

Worker — Processus qui traite des tâches asynchrones.

X

XSS — Cross-Site Scripting. Attaque par injection de scripts.

X-Request-ID — Header HTTP pour corrélation de requêtes.

Y

YAML — YAML Ain't Markup Language. Format de sérialisation pour configuration.

Z

ZooKeeper — Service de coordination distribuée.

ZSTD — Algorithme de compression rapide.

---

B. Cheat Sheet Docker

Commandes Essentielles

# Images
docker build -t app:latest .          # Build image
docker pull node:20-alpine            # Pull image
docker push user/app:latest           # Push image
docker images                         # Lister les images
docker rmi app:latest                 # Supprimer image
docker image prune -a                 # Nettoyer images non utilisées

# Containers
docker run -d --name app -p 3000:3000 app:latest    # Lancer container
docker run -it --rm node:20-alpine /bin/sh          # Mode interactif
docker ps                                           # Lister containers actifs
docker ps -a                                        # Lister tous les containers
docker stop app                                     # Arrêter container
docker start app                                    # Démarrer container
docker rm app                                       # Supprimer container
docker rm -f $(docker ps -aq)                       # Supprimer tous les containers

# Logs et debug
docker logs -f app                    # Logs temps réel
docker logs --tail 100 app            # Dernières 100 lignes
docker exec -it app /bin/sh           # Shell dans le container
docker inspect app                    # Infos détaillées
docker stats                          # Stats CPU/mémoire
docker top app                        # Processus dans le container

# Volumes
docker volume ls                      # Lister volumes
docker volume inspect app-data        # Infos volume
docker volume prune                   # Supprimer volumes orphelins

# Réseau
docker network ls                     # Lister réseaux
docker network create backend         # Créer réseau
docker network connect backend app    # Connecter container

# Docker Compose
docker compose up                     # Démarrer services
docker compose up -d                  # Démarrer en arrière-plan
docker compose down                   # Arrêter et nettoyer
docker compose down -v                # Arrêter + supprimer volumes
docker compose logs -f                # Logs de tous les services
docker compose ps                     # État des services
docker compose build                  # Rebuild images
docker compose exec app /bin/sh       # Shell dans un service

# Nettoyage
docker system prune                   # Nettoyage général
docker system prune -a --volumes      # Nettoyage complet

Dockerfile Patterns

# Multi-stage
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:20-alpine AS runner
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
CMD ["node", "dist/main.js"]

# Développement
FROM node:20-alpine AS dev
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
CMD ["npm", "run", "dev"]

Bonnes Pratiques

1. Multi-stage builds pour réduire la taille de l'image finale
2. Copier package.json d'abord pour exploiter le cache des layers
3. Éviter root : USER node/appuser
4. Healthcheck intégré
5. Utiliser des images officielles avec digest (sha256)
6. Minimiser les layers : RUN commands combinées
7. .dockerignore pour exclure node_modules, .git
8. Utiliser tini comme ENTRYPOINT pour gérer les signaux

---

C. Cheat Sheet Kubernetes

kubectl Commandes

# Pods
kubectl get pods                          # Lister les pods
kubectl get pods -n production            # Dans un namespace
kubectl get pods -l app=backend           # Label selector
kubectl describe pod nginx-xxx            # Infos détaillées
kubectl logs pod-xxx                      # Logs d'un pod
kubectl logs -f deployment/app            # Logs temps réel
kubectl exec -it pod-xxx -- /bin/sh       # Shell dans le pod
kubectl port-forward pod-xxx 3000:3000    # Port forwarding

# Deployments
kubectl get deployments                   # Lister les déploiements
kubectl create deployment app --image=app:latest
kubectl scale deployment app --replicas=5
kubectl set image deployment/app app=app:v2
kubectl rollout status deployment/app
kubectl rollout undo deployment/app       # Rollback
kubectl rollout history deployment/app    # Historique

# Services
kubectl get svc                           # Lister les services
kubectl expose deployment app --port=80 --type=LoadBalancer
kubectl describe svc app

# Config et Secrets
kubectl create configmap app-config --from-file=config.yaml
kubectl create secret generic app-secret --from-literal=key=value
kubectl get secrets
kubectl describe secret app-secret

# Debug
kubectl top pods                          # CPU/mémoire
kubectl top nodes                         # Ressources nœuds
kubectl get events --sort-by='.lastTimestamp'
kubectl get nodes                         # Lister les nœuds
kubectl cordon node-xxx                   # Marquer comme non-schedulable
kubectl drain node-xxx                    # Évacuer les pods

# Namespace
kubectl get namespaces
kubectl create namespace production
kubectl config set-context --current --namespace=production

# Utilitaires
kubectl api-resources                     # Lister les ressources API
kubectl explain deployment                # Documentation d'une ressource
kubectl apply -f deployment.yaml          # Appliquer un fichier
kubectl delete -f deployment.yaml         # Supprimer
kubectl diff -f deployment.yaml           # Comparer avant apply

YAML Essentiels

# Deployment
apiVersion: apps/v1
kind: Deployment
metadata:
  name: app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: backend
  template:
    metadata:
      labels:
        app: backend
    spec:
      containers:
      - name: app
        image: app:latest
        ports:
        - containerPort: 3000
        env:
        - name: NODE_ENV
          value: "production"
        resources:
          requests: { cpu: "250m", memory: "256Mi" }
          limits: { cpu: "500m", memory: "512Mi" }
        livenessProbe:
          httpGet: { path: /health, port: 3000 }
        readinessProbe:
          httpGet: { path: /ready, port: 3000 }

# Service
apiVersion: v1
kind: Service
metadata:
  name: app-service
spec:
  selector:
    app: backend
  ports:
  - port: 80
    targetPort: 3000
  type: ClusterIP

# ConfigMap
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  NODE_ENV: "production"
  LOG_LEVEL: "info"

# HPA
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: app
  minReplicas: 3
  maxReplicas: 20
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

---

D. Cheat Sheet SQL

Requêtes Essentielles

-- CRUD
INSERT INTO users (name, email) VALUES ('John', 'john@example.com');
SELECT * FROM users WHERE id = 1;
SELECT id, name FROM users WHERE email LIKE '%@example.com' ORDER BY created_at DESC;
UPDATE users SET name = 'Jane' WHERE id = 1;
DELETE FROM users WHERE id = 1 RETURNING *;

-- Jointures
SELECT u.name, o.id, o.total
FROM users u
INNER JOIN orders o ON u.id = o.user_id;

SELECT u.name, o.id
FROM users u
LEFT JOIN orders o ON u.id = o.user_id;

-- Agrégations
SELECT user_id, COUNT(*) as order_count, SUM(total) as total_spent
FROM orders
WHERE created_at >= NOW() - INTERVAL '30 days'
GROUP BY user_id
HAVING COUNT(*) > 5
ORDER BY total_spent DESC;

-- Fenêtres (Window Functions)
SELECT name, email,
  ROW_NUMBER() OVER (PARTITION BY department_id ORDER BY salary DESC) as rank,
  AVG(salary) OVER (PARTITION BY department_id) as dept_avg
FROM employees;

-- Sous-requêtes
SELECT * FROM users
WHERE id IN (SELECT user_id FROM orders WHERE total > 100);

-- CTE
WITH recent_orders AS (
  SELECT user_id, COUNT(*) as cnt
  FROM orders
  WHERE created_at > NOW() - INTERVAL '7 days'
  GROUP BY user_id
)
SELECT u.name, COALESCE(ro.cnt, 0) as recent_orders
FROM users u
LEFT JOIN recent_orders ro ON u.id = ro.user_id;

Index

-- Types d'index
CREATE INDEX idx_users_email ON users(email);                          -- B-tree (default)
CREATE UNIQUE INDEX idx_users_email_unique ON users(email);           -- Unique
CREATE INDEX idx_orders_created ON orders(created_at DESC);           -- Orderé
CREATE INDEX idx_products_search ON products USING GIN(search_vector); -- Full-text
CREATE INDEX idx_orders_user_status ON orders(user_id, status);       -- Composite
CREATE INDEX idx_users_active ON users(is_active) WHERE is_active;    -- Partiel
CREATE INDEX idx_hash ON users USING HASH(id);                        -- Hash

-- Analyse
EXPLAIN ANALYZE SELECT * FROM users WHERE email = 'test@test.com';
ANALYZE users;  -- Mettre à jour les statistiques

Transactions

BEGIN;
UPDATE accounts SET balance = balance - 100 WHERE id = 1;
UPDATE accounts SET balance = balance + 100 WHERE id = 2;
COMMIT;
-- ou ROLLBACK en cas d'erreur

Performances

-- Slow queries
SELECT query, calls, total_exec_time, mean_exec_time
FROM pg_stat_statements
ORDER BY mean_exec_time DESC
LIMIT 10;

-- Taille des tables
SELECT relname, pg_size_pretty(pg_total_relation_size(relid))
FROM pg_catalog.pg_statio_user_tables;

---

E. Cheat Sheet Redis

Types et Commandes

# String (clé-valeur simple)
SET user:1:name "John"
GET user:1:name
SETEX session:xxx 3600 "data"    # TTL
TTL session:xxx

# List (File d'attente)
LPUSH queue:email "msg1"         # Push à gauche
RPUSH queue:email "msg2"         # Push à droite
LPOP queue:email                 # Pop à gauche
LLEN queue:email                 # Longueur
LRANGE queue:email 0 -1          # Lire toute la liste

# Set (Ensemble unique)
SADD tags:post:1 "backend"
SISMEMBER tags:post:1 "backend"
SMEMBERS tags:post:1
SINTER post:1:tags post:2:tags   # Intersection

# Sorted Set (Classement)
ZADD leaderboard 1000 "user1"
ZINCRBY leaderboard 50 "user1"
ZRANGE leaderboard 0 9 REV WITHSCORES   # Top 10
ZRANK leaderboard "user1"               # Position

# Hash (Objet)
HSET user:1 name "John" email "john@example.com"
HGETALL user:1
HGET user:1 name

# Stream (Messages)
XADD mystream * sensor-id 1234 temperature 19.8
XRANGE mystream - + COUNT 10
XREAD COUNT 10 BLOCK 0 STREAMS mystream 0

# Pub/Sub
PUBLISH channel:updates "message"
SUBSCRIBE channel:updates

Patterns

# Rate Limiter (sliding window)
-- EVALSHA script 1 rate_limit:user:123
local key = KEYS[1]
local now = redis.call('TIME')[1]
local window = ARGV[1]   -- 60s
local limit = tonumber(ARGV[2])  -- 100
redis.call('ZREMRANGEBYSCORE', key, 0, now - window)
local count = redis.call('ZCARD', key)
redis.call('ZADD', key, now, now .. ':' .. math.random())
redis.call('EXPIRE', key, window)
return count < limit

# Distributed Lock
SET lock:resource1 "uuid-xxx" NX EX 30
-- Traitement...
DEL lock:resource1

# Session Store
SETEX session:abc123 3600 '{"userId": 1, "role": "admin"}'

# Cache Aside
GET cache:product:123                    # Try cache
-- Si miss : query DB, puis SETEX cache:product:123 300 $data

---

F. Cheat Sheet Git

Workflow Quotidien

git status                          # État du working tree
git add <file>                      # Stage un fichier
git add .                           # Stage tout
git commit -m "feat: add login"     # Commit
git commit --amend                  # Modifier dernier commit

git pull --rebase                   # Pull avec rebase
git push                            # Push
git push -u origin feature/xxx      # Premier push d'une branche

git branch                          # Lister branches
git checkout -b feature/xxx         # Créer et basculer
git switch feature/xxx              # Basculer (Git 2.23+)
git merge feature/xxx               # Fusionner
git rebase main                     # Rebase sur main

git stash                           # Sauvegarder temporairement
git stash pop                       # Restaurer stash
git stash list                      # Lister les stashs

Résolution de Problèmes

git log --oneline --graph           # Historique compact
git log --all --graph               # Toutes les branches
git blame file.ts                   # Qui a modifié quoi ?
git diff                            # Modifications non stagées
git diff --staged                   # Modifications stagées

git reset HEAD~1                    # Annuler dernier commit (local)
git revert HEAD                     # Annuler avec nouveau commit
git reset --hard HEAD               # Rejeter modifications locales
git clean -fd                       # Supprimer fichiers non trackés

Workflows

Feature Branch :

git checkout -b feature/user-api
# ... code ...
git add . && git commit -m "feat: add user API"
git checkout main
git pull --rebase
git merge feature/user-api
git push

Hotfix :

git checkout -b hotfix/critical-bug main
# ... fix ...
git commit -m "fix: critical security patch"
git checkout main && git merge hotfix/critical-bug
git checkout develop && git merge hotfix/critical-bug
git branch -d hotfix/critical-bug

---

G. Commandes Essentielles

Linux / Terminal

# Processus
ps aux | grep node                  # Processus Node.js en cours
top -o %CPU                         # Processus par CPU
htop                                # Meilleur que top
kill -9 <PID>                       # Forcer l'arrêt
lsof -i :3000                       # Quoi écoute sur le port 3000 ?

# Réseau
curl -v http://localhost:3000/health    # Test API
curl -X POST -H "Content-Type: application/json" -d '{"name":"test"}' http://localhost:3000/api
ping google.com                          # Test connectivité
traceroute google.com                    # Traceroute
netstat -tulpn                           # Ports ouverts
ss -tulpn                                # Alternative moderne
nslookup google.com                      # DNS lookup

# Disque
df -h                                    # Espace disque
du -sh *                                 # Taille des dossiers
ncdu                                     # Analyse disque interactive
iostat -x 1                              # I/O disque

# Mémoire
free -h                                  # RAM
vmstat 1                                 # Statistiques système

# Fichiers
find . -name "*.ts"                      # Chercher fichiers
grep -r "TODO" src/                      # Chercher dans les fichiers
wc -l src/**/*.ts                        # Compter lignes de code
tail -f app.log                          # Logs temps réel
less app.log                             # Lecture paginée
head -n 100 app.log                      # Premières lignes

Diagnostics Réseau

# DNS
dig google.com ANY
dig -x 8.8.8.8                    # Reverse DNS

# HTTP
curl -v https://api.example.com
curl -o /dev/null -s -w 'Total: %{time_total}s\n' https://example.com
http https://api.example.com       # HTTPie (alternative curl)

# SSL/TLS
openssl s_client -connect example.com:443 -tls1_3

# Bande passante
iperf3 -c server -p 5201          # Test bande passante
iftop                              # Bande passante par connexion

# Tcpdump
tcpdump -i eth0 port 80           # Capturer trafic HTTP
tcpdump -i eth0 host 10.0.0.1     # Trafic d'une IP

Scripts Utiles

# Watch and rerun
while inotifywait -e modify src/; do npm run build; done

# Monitorer les logs
tail -f app.log | grep ERROR

# Backup base de données
pg_dump -U app app_db > backup.sql
psql -U app app_db < backup.sql

# Compresser/décompresser
tar -czf archive.tar.gz src/
tar -xzf archive.tar.gz

---

H. Cheat Sheet Messages de Commit Conventionnels

feat: allow provided config object to extend other configs
feat(lang): add polish language
fix: correct minor typos in code
fix(api): handle 404 for unknown users
docs: correct spelling in README
style: format everything with prettier
refactor: extract user validation logic
perf: improve database query performance
test: add user registration integration tests
build: update npm dependencies
ci: add GitHub Actions workflow
chore: update eslint config
revert: revert "feat: add user search"
security: fix SQL injection vulnerability
deps: upgrade express to v4.19

---

I. Cheat Sheet HTTP Status Codes