Main Page

From Essential
Revision as of 12:34, 3 October 2026 by Tcepo (talk | contribs) (scission Top tasks: infra déployée + veille GitHub)
Jump to navigation Jump to search
Discover cloud and AI on infocepo.com

infocepo.com – Cloud, AI & Labs

Bienvenue sur le portail infocepo.com.

Ce wiki documente l’écosystème Cloud, IA, automatisation et lab d’Infocepo. Il s’adresse aux :

  • administrateurs systèmes,
  • ingénieurs cloud,
  • développeurs,
  • étudiants,
  • curieux qui veulent apprendre en pratiquant.

L’objectif est simple : transformer la théorie en scripts réutilisables, schémas, architectures, APIs et laboratoires concrets.

Accès rapide

Portail principal

Assistant IA

Liste des pages du wiki

Vue d’ensemble

Infra architecture overview

Démarrer rapidement

Parcours recommandés

1. Construire un assistant IA privé
  • Déployer une stack type Hermes WebUI + Ollama + GPU
  • Ajouter un modèle de chat et un modèle de résumé
  • Brancher des données internes via RAG + embeddings
2. Lancer un lab cloud
  • Créer un petit cluster Kubernetes, OpenStack ou bare-metal
  • Mettre en place un pipeline de déploiement (Helm, Ansible, Terraform…)
  • Ajouter un service IA : transcription, résumé, chatbot, OCR…
3. Préparer un audit ou une migration
  • Inventorier les serveurs avec ServerDiff.sh
  • Concevoir l’architecture cible
  • Automatiser la migration avec des scripts reproductibles

Vue d’ensemble du contenu

  • Guides IA & outils : assistants, modèles, évaluation, GPU, RAG
  • Cloud & infrastructure : Kubernetes, OpenStack, HA, HPC, DevSecOps
  • Labs & scripts : audit, migration, automatisation
  • Comparatifs : Kubernetes vs OpenStack vs AWS vs bare-metal, etc.

Vision

The world after automation

Le but à long terme est de construire un environnement où :

  • les assistants IA privés accélèrent la production,
  • les tâches répétitives sont automatisées,
  • les déploiements sont industrialisés,
  • l’infrastructure reste compréhensible, portable et réutilisable.

Chaque sortie IA est mesurée en temps réel, les modèles faibles sont remplacés automatiquement, et les tâches sans valeur sont coupées. L'autonomie vient de mécanismes techniques qui fonctionnent quand personne ne regarde — pas de règles écrites dans un doc.

Main page summary

Catalogue rapide des services

Services principaux
Catégorie Service Rôle
API LLM Modèles de chat, code, RAG, OCR
API STT Transcription audio
API TTS Synthèse vocale
API realtime-ai Temps réel WebSocket / WebRTC
API IMAGE2TXT OCR / VLM via endpoint dédié
API summary Résumé de textes longs
API EMBEDDINGS Embeddings pour RAG
API ChromaDB Base vecteur
API TXT2IMAGE Génération d’images
API diarization Segmentation locuteurs
Observabilité monitoring Dashboards techniques
Observabilité status Disponibilité des services
Observabilité web-stat Statistiques web
Observabilité LLM-stat Vue API / usage
Outils dataLab Environnement de travail hors-production
Outils realtime translation Traduction
Outils Demos Démonstrateurs

Sélection AI & architecture par couche

Le tableau de bord Sélection AI présente l'architecture par couche des modèles IA déployés :

Couche Modèle Alias(s) Taille
HYBRID-CLOUD Qwen3.6-35B flash, default, thinking, vision Option 1, 35B MoE / 3B actif
Qwen3.8-Flash-Next flash, default, thinking, vision, max Option 2, 125B MoE, 51B n-grames internes, 6B actif, 1M contexte
MiniMax-H3 video 33B dense
BGE-M3 embedding 568M
BGE-reranker-v2-m3 reranker 568M
FLUX.2-klein-4B image 4B
GLiNER2.5-Multi-V1 privacy 287M, mDeBERTa-v3-base — privacy filter: api-llm-privacy-proxy-gliner2
Public-Cloud GLM-5.3-Flash max 320B MoE / 18B actif — 1M contexte, multimodal
LOCAL Qwen3.5-9B flash, default, thinking, vision Option 1, 9B dense
Qwen3.8-27B flash, default, thinking, vision, max Option 2, 27B dense

Frameworks

Outil Usage
Hermes Usage général, raisonnement
OpenCode DevSecOps
Kilo Code Développement pur

Mémoire

Pour la couche d'embedding vectoriel (RAG, mémoire sémantique) :

  • BGE-M3 — 568M paramètres, architecture XLM-RoBERTa. Multi-fonction (dense + sparse + multi-vector), 100+ langues, licence MIT. Idéal comme moteur de mémoire à échelle.

Nouveautés

Nouveautés implémentés

  • api-audio2txt (2026-09-25) : Fast audio-to-text transcription API with real-time Whisper model support
  • translate-rt (2026-09-24) : Real-time translation API — multilingual translation with low latency
  • api-txt2image (2026-09-20) : Text-to-image generation API for AI-powered image creation
  • api-rag (2026-09-19) : RAG API — semantic search over knowledge bases with retrieval-augmented generation
  • gouv-fr-code-package-mi (2026-09-19) : gouv-fr-code-package-mi
  • agent-saas (2026-09-17) : SaaS AI agent platform — deploy autonomous AI agents as a service
  • api-llm-privacy-proxy-gliner2-5 (2026-09-16) : api-llm-privacy-proxy-gliner2-5
  • qwen36-sglang (2026-09-15) : Qwen 3.6 deployment with SGLang for high-performance inference
  • omnivoice-tts (2026-09-13) : omnivoice-tts
  • api-llm-privacy-proxy-gliner2 (2026-09-10) : GLiNER2-powered LLM privacy proxy for named entity detection and filtering
  • tricoteuses-k8s (2026-09-08) : Kubernetes deployment for tricoteuses-juridique
  • dashboard-superset-mcp (2026-09-03) : Automate Apache Superset dashboard creation via MCP server 6.1.0+
  • superset-k8s (2026-09-01) : superset-k8s
  • dind-build (2026-08-31) : Docker-in-Docker build factory on Kubernetes — build, push, pull via K8s DinD pod
  • quality-gate (2026-08-28) : quality-gate
  • api-convert2md (2026-08-26) : Document-to-Markdown conversion API — clean markdown from various formats
  • trafilatura-local (2026-08-23) : trafilatura-local
  • models-todo (2026-08-19) : models-todo
  • minimax-music3 (2026-08-18) : minimax-music3
  • hermes-img-gen-infocepo (2026-08-15) : hermes-img-gen-infocepo
  • api-llm-custom (2026-08-13) : Custom LLM proxy API — route requests to any language model backend
  • infocepo-infra-mcp (2026-08-12) : infocepo-infra-mcp
  • api-mcp-openai (2026-08-11) : AI MCP OpenAI Integration
  • api-embedding (2026-08-07) : Text embedding API — convert text to vector embeddings for semantic search
  • api-reranker (2026-08-06) : Cross-encoder reranking API for improving search retrieval quality

Top tasks — infrastructure déployée

Généré depuis l'infra réelle (kubectl + endpoints LLM) le 2026-10-03. Ne pas éditer à la main — regénérer après déploiement.

Endpoints LLM (vérifiés)

Endpoint Modèle réel URL
ai-thinking qwen3.6 (thinking) https://api-nothink.ailab.infocepo.com
ai-default qwen3.6 (défaut) https://api-nothink.ailab.infocepo.com
ai-flash qwen3.6 (fast) https://api-nothink.ailab.infocepo.com
ai-vision qwen3.6 (vision/OCR) https://api-nothink.ailab.infocepo.com
ai-embedding bge-m3 https://api-embedding.ailab.infocepo.com

Services & infrastructure IA

Benchmarks & évaluation

Veille automatisée

Veille GitHub (populaire)

  • transformers (2026-10-03) : Framework pour modèles de ML - transformers, embeddings, NLP (166k⭐)
  • unsloth (2026-10-03) : Interface locale pour exécuter et entraîner LLMs et modèles diffusion - GGUF, MLX, Qwen3.8, DeepSeek (77k⭐)
  • litellm (2026-10-03) : Passerelle AI rapide - Gateway Rust + SDK Python. 100+ APIs LLM en une (60k⭐)
  • vllm (2026-09-29) : A high-throughput and memory-efficient inference and serving engine for LLMs (93k⭐)
  • OpenHands (2026-09-29) : AI-Driven Development: open-source AI agent platform (89k⭐)
  • LibreChat (2026-09-29) : Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API (45k⭐)
  • n8n (2026-09-27) : Fair-code workflow automation platform with native AI capabilities. Combine visual building with custom code, self-host or use cloud. (206k⭐)
  • qwen-code (2026-09-27) : An open-source AI coding agent that lives in your terminal. (28k⭐)
  • ai (2026-09-27) : The AI Toolkit for TypeScript. From the creators of Next.js, the AI SDK is a free open-source library for building AI-powered chatbots, assistants and more. (26k⭐)

Backlog / Veille Technologique

Agents IA & Orchestration

  • LangChain : Framework pour applications basées sur les LLM. Le plus mature. (145k⭐).
  • Dify : Plateforme de développement d'applications IA (LLM Ops). Déployable en self-host. (154k⭐).
  • open-webui : Interface web IA (Ollama, OpenAI API, MCP). (151k⭐).
  • ollama : Get up and running with Kimi-K2.6, GLM-5.2, MiniMax, DeepSeek, gpt-oss, Qwen, Gemma and other models. (180k⭐).
  • milvus : Base de données vectorielle haute performance. (46k⭐).

Audio & TTS

Génération & Édition d'Images

  • ComfyUI  : GUI et backend diffusion model le plus modulaire. (131k⭐)

RAG & Traitement de Documents

  • paperless-ngx : Document management : scan, index, archive. ML, OCR. (45k⭐).
  • graphify : Transforme codebase en graphe de connaissances interrogeable. (115k⭐).
  • LightRAG : RAG simple et rapide. (39k⭐).
  • graphrag : RAG modulaire basé sur les graphes. (35k⭐).
  • headroom : Compress tool outputs, logs, files et RAG chunks. 20-95% token savings. (69k⭐).
  • Mem0 : — Mémorie à long terme pour agents IA. (64k⭐).

APIs à Développer

  • Classificateur IA — Classification de contenu.
  • Résumé mutualisé — API de résumé de texte partagée.
  • NER — Reconnaissance d'entités nommées.
  • Compressor — Compression de contenu.

Infrastructure & Backend

Outils Dev

  • Aider — Assistant de codage IA en ligne de commande.
  • Continue — Extension IDE IA (VS Code, JetBrains). (35k⭐)
  • TensorRT-LLM (2026-09-30) : TensorRT LLM provides users with an easy-to-use Python API to define Large Language Models (LLMs) and supports state-of-... (14k stars)
  • netron (2026-09-30) : Visualizer for neural network, deep learning and machine learning models (33k stars)
  • omi (2026-09-30) : AI that sees your screen, listens to your conversations and tells you what to do (13k stars)

Assistants IA & outils cloud

Assistants IA

Assistants IA auto-hébergés
Stack typique pour assistant privé, API OpenAI-compatible et expérimentation locale.

Développement, modèles & veille

Découverte de modèles
Évaluation & benchmarks
Outils de développement & fine-tuning

Matériel IA & GPU

API Realtime AI (DEV)

Statut : environnement DEV, remplaçante prévue de l’API OpenAI pour les cas temps réel.

Configuration

Variable Valeur
OPENAI_API_BASE wss://api-realtime-ai.ailab.infocepo.com:wait-2026-12/v1
OPENAI_API_KEY sk-XXXXX

Dépôt GitHub

Page de test

  • external-test/half-duplex.html — annulation d’écho + mode half-duplex.

Compatibilité

Remplacer l’URL OpenAI par $OPENAI_API_BASE pour tester compatibilité et performances.

API LLM (OpenAI compatible)

Liste des modèles

curl -X GET \
  'https://api-nothink.ailab.infocepo.com/v1/models' \
  -H 'Authorization: Bearer sk-XXXXX' \
  -H 'accept: application/json' \
  | jq | sed -rn 's#^.*id.*: "(.*)".*$#* \1#p' | sort -u

Modèles ouverts & endpoints internes

Dernière mise à jour : 2026-06-30

Les modèles ci-dessous correspondent à des endpoints logiques exposés derrière une passerelle.

Endpoint Description / usage principal
ai-thinking qwen3.6 fp8 – thinking
ai-fast qwen3.6 fp8 en mode fast – vision/OCR/ai-default
ai-embedding bge-m3 – recherche sémantique
ai-stt whisper3-turbo – transcription vocale multilingual
ai-tts OmniVoice – TTS multilingual
ai-image OpenDalle – image génération

Exemple bash

export OPENAI_API_MODEL="ai-default"
export OPENAI_API_BASE="https://api-nothink.ailab.infocepo.com/v1"
export OPENAI_API_KEY="sk-XXXXX"

promptValue="Quel est ton nom ?"
jsonValue='{
  "model": "'${OPENAI_API_MODEL}'",
  "messages": [{"role": "user", "content": "'${promptValue}'"}],
  "temperature": 0
}'

curl ${OPENAI_API_BASE}/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d "${jsonValue}" 2>/dev/null | jq '.choices[0].message.content'

Vue infra LLM

File:Litellm-proxy-mermaid-diagram-2024-03-24-205202.png

DEV (au choix)

  • A. LiteLLM → vLLM/SgLang : tests perf / compatibilité
  • B. LiteLLM → Ollama : simple, rapide à itérer
  • C. Ollama direct : POC ultra-léger

DEV – modèle FR / résumé

  • LiteLLM → Ollama /v1

PROD

  • Standard : LiteLLM → vLLM/SgLang
  • Pont DEV→PROD : LiteLLM (DEV) → LiteLLM (PROD) → vLLM/SgLang

Notes :

  • LiteLLM = passerelle unique (clés, quotas, logs)
  • vLLM/SgLang = performance / stabilité en charge
  • Ollama = simplicité de prototypage

API Image to Text

  • Utilise l’API LLM avec un endpoint adapté à l’OCR / VLM.
  • Modèle recommandé : ai-vision

Exemple bash

OPENAI_API_KEY=sk-XXXXX

base64 -w0 "/path/to/image.png" > img.b64

jq -n --rawfile img img.b64 \
'{
  model: "ai-vision",
  messages: [
    {
      role: "user",
      content: [
        { "type": "text", "text": "Décris cette image." },
        {
          "type": "image_url",
          "image_url": { "url": ("data:image/png;base64," + ($img | rtrimstr("\n"))) }
        }
      ]
    }
  ]
}' > payload.json

curl https://api-nothink.ailab.infocepo.com/v1/chat/completions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  --data-binary @payload.json

Exemple Python

import base64
import json
import requests
import os

API_KEY = os.getenv("OPENAI_API_KEY")
MODEL = "ai-vision"
IMG_PATH = "/path/to/image.png"
API_URL = "https://api-nothink.ailab.infocepo.com/v1/chat/completions"

with open(IMG_PATH, "rb") as f:
    img_b64 = base64.b64encode(f.read()).decode("utf-8")

payload = {
    "model": MODEL,
    "messages": [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Décris cette image."},
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/png;base64,{img_b64}"}
                }
            ]
        }
    ]
}

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

response = requests.post(API_URL, headers=headers, data=json.dumps(payload))

if response.ok:
    print(json.dumps(response.json(), indent=2, ensure_ascii=False))
else:
    print(f"Erreur {response.status_code}: {response.text}")

API STT

Exemple Python

import requests

OPENAI_API_KEY = 'sk-XXXXX'

url = 'https://api-audio2txt.ailab.infocepo.com/v1/audio/transcriptions'
headers = {
    'Authorization': f'Bearer {OPENAI_API_KEY}',
}
files = {
    'file': ('file.opus', open('/path/to/file.opus', 'rb')),
    'model': (None, 'whisper-1')
}

response = requests.post(url, headers=headers, files=files)
print(response.json())

Exemple curl

[ ! -f /tmp/test.ogg ] && wget "https://upload.wikimedia.org/wikipedia/commons/1/17/Fables_de_La_Fontaine_Livre_1_01.ogg" -O /tmp/test.ogg

export OPENAI_API_KEY=sk-XXXXX

curl https://api-audio2txt.ailab.infocepo.com/v1/audio/transcriptions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -F model="whisper-1" \
  -F file="@/tmp/test.ogg"

Notes

  • Plusieurs formats audio sont acceptés.
  • Le flux final est normalisé en 16 kHz mono.
  • Pour une qualité optimale : privilégier OPUS 16 kHz mono.

UI

API TTS

Exemple

export OPENAI_API_KEY=sk-XXXXX

curl https://api-tts-omnivoice.ailab.infocepo.com/v1/audio/speech \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o-mini-tts",
    "input": "Bonjour, ceci est un test de synthèse vocale.",
    "voice": "coral",
    "instructions": "Speak in a cheerful and positive tone.",
    "response_format": "opus"
  }' | ffplay -i -

API Text to Image

Exemple

export OPENAI_API_KEY=EMPTY

curl https://api-txt2image.ailab.infocepo.com/v1/images/generations \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "prompt": "a photo of a happy corgi puppy sitting and facing forward, studio light, longshot",
    "n": 1,
    "size": "1024x1024"
  }'

API Diarization

Exemple

wget "https://upload.wikimedia.org/wikipedia/commons/6/60/Mike_Peters_on_Politics_and_Emotion_%28Interview_1984%29.mp3" -O /tmp/test.mp3

curl -X POST "https://api-diarization.ailab.infocepo.com/upload-audio/" \
  -H "Authorization: Bearer token1" \
  -F "file=@/tmp/test.mp3"

API Summary

Exemple

text="The tower is 324 metres tall and is one of the most recognizable monuments in the world."

json_payload=$(jq -nc --arg text "$text" '{"text": $text}')

curl -X POST https://api-summary.ailab.infocepo.com:wait-2026-12/summary/ \
  -H "Content-Type: application/json" \
  -d "$json_payload"

API Text Embeddings

Exemple

curl https://api-embedding.ailab.infocepo.com/v1/embeddings \
  -X POST \
  -d '{"model":"bge-m3","input":"What is Deep Learning?"}' \
  -H 'Content-Type: application/json'

API DB Vectors (ChromaDB)

Production

Lab

export CHROMA_HOST=https://chromadb.c1.ailab.infocepo.com:wait-2026-12
export CHROMA_PORT=443
export CHROMA_TOKEN=XXXX

Exemple curl

curl -v "${CHROMA_HOST}"/api/v1/collections \
  -H "Authorization: Bearer ${CHROMA_TOKEN}"

Exemple Python

import chromadb
from chromadb.config import Settings

def chroma_http(host, port=80, token=None):
    return chromadb.HttpClient(
        host=host,
        port=port,
        ssl=host.startswith('https') or port == 443,
        settings=(
            Settings(
                chroma_client_auth_provider='chromadb.auth.token.TokenAuthClientProvider',
                chroma_client_auth_credentials=token,
            ) if token else Settings()
        )
    )

client = chroma_http(CHROMA_HOST, CHROMA_PORT, CHROMA_TOKEN)
collections = client.list_collections()
print(collections)

Déployer sa propre instance

export nameSpace=your_namespace
domainRoot=ailab.infocepo.com

helm repo add chroma https://amikos-tech.github.io/chromadb-chart/
helm repo update

helm upgrade --install chromadb chroma/chromadb -n ${nameSpace} \
  --set chromadb.apiVersion="0.4.24" \
  --set ingress.enabled=true \
  --set ingress.hosts[0].host="${nameSpace}-chromadb.${domainRoot}" \
  --set ingress.hosts[0].paths[0].path=/ \
  --set ingress.hosts[0].paths[0].pathType=ImplementationSpecific \
  --set ingress.annotations."cert-manager\.io/cluster-issuer"=letsencrypt-prod \
  --set ingress.tls[0].secretName=${nameSpace}-chromadb.${domainRoot}-tls \
  --set ingress.tls[0].hosts[0]="${nameSpace}-chromadb.${domainRoot}"

kubectl -n ${nameSpace} patch ingress/chromadb --type=json \
  -p '[{"op":"add","path":"/metadata/annotations/nginx.ingress.kubernetes.io~1proxy-body-size","value":"0"}]'

Récupérer le token

kubectl --namespace ${nameSpace} get secret chromadb-auth \
  -o jsonpath="{.data.token}" | base64 --decode && echo

Registry

Exemple

curl -u "user:XXXXX" https://registry.ailab.infocepo.com:wait-2026-09/v2/_catalog

Exemple K8S

deploymentName=
nameSpace=

kubectl -n ${nameSpace} create secret docker-registry pull-secret \
  --docker-server=registry.ailab.infocepo.com:wait-2026-09 \
  --docker-username=user \
  --docker-password=XXXXX \
  --docker-email=contact@example.com

kubectl -n ${nameSpace} patch deployment ${deploymentName} \
  -p '{"spec":{"template":{"spec":{"imagePullSecrets":[{"name":"pull-secret"}]}}}}'

Stockage objet externe (S3)

Un bucket nommé ORG a été créé pour stocker des documents de démonstration.

RAG optimisation

  • Embeddings : BAAI/bge-m3
  • chunk_size=1000
  • chunk_overlap=100
  • LLM : qwen3.6
  • Pour les PDF mixtes : PDF → image → OCR / VLM peut améliorer les résultats.

Workflow

Autoroute directe : code → CI/CD → deploy → monitoring. Pas de comité, pas de responsable désigné — chaque étape se déclenche automatiquement si la précédente passe. Si ça rate, alerte directe sans passer par un humain sauf décision explicite de fallback.

Environnements

Hors production

  • Utiliser datalab
  • Support : canal Mattermost Offre IA
  • Le pseudo utilisateur doit respecter la convention interne
  • Demander si besoin un accès Linux + Kubernetes

Production (best-effort)

  • Publier le code applicatif, les secrets (format SOPS), le Dockerfile et le code infra (Helm ou manifests K8S) sur Git
  • Demander un namespace
  • Lire la documentation de surveillance associée

Limites de l’infrastructure

  • Les charges GPU sont intentionnellement limitées en journée.
  • Coût unitaire mesuré automatiquement (dashboards temps réel, pas Excel).

Cloud Lab & projets d’audit

Cloud Lab reference diagram

Le Cloud Lab fournit des scénarios reproductibles : audit d’infrastructure, migration cloud, automatisation, haute disponibilité.

Projet d’audit

ServerDiff.sh

Script Bash d’audit permettant de :

  • détecter les dérives de configuration,
  • comparer plusieurs environnements,
  • préparer un plan de migration ou de remédiation.

Exemple de migration cloud

Cloud migration diagram

Tâche Description Durée (jours)
Audit infrastructure 82 services, audit automatisé via ServerDiff.sh 1.5
Diagramme d’architecture Conception visuelle et documentation 1.5
Contrôles de conformité 2 clouds, 6 hyperviseurs, 6 To RAM 1.5
Installation plateforme cloud Déploiement des environnements cibles 1.0
Vérification de stabilité Premiers tests fonctionnels 0.5
Étude d’automatisation Identification des tâches répétitives 1.5
Développement des templates 6 templates, 8 environnements, 2 clouds / OS 1.5
Diagramme de migration Illustration du processus 1.0
Écriture du code de migration 138 lignes (voir MigrationApp.sh) 1.5
Stabilisation Validation de la reproductibilité 1.5
Benchmark cloud Comparaison vs legacy 1.5
Réglage des temps d’arrêt Calcul du downtime 0.5
Chargement VM 82 VMs : OS, code, 2 IP par VM 0.1
Total 15 jours.homme

Vérifications de stabilité (HA minimale)

Action Résultat attendu
Extinction d’un nœud Tous les services redémarrent automatiquement sur les autres nœuds
Extinction / redémarrage simultané de tous les nœuds Les services repartent correctement après reboot


Autonomie testée : vérifier que la migration fonctionne seule en tirant le repo et lançant le script, sans personne qui connaît le système de tête.

Architecture web & bonnes pratiques

Reference web architecture

Principes de conception :

  • privilégier une infrastructure simple, modulaire et flexible,
  • rapprocher le contenu du client (GDNS ou équivalent),
  • utiliser des load balancers réseau (LVS, IPVS),
  • comparer les coûts et éviter le vendor lock-in,
  • pour TLS :
    • HAProxy pour les frontends rapides,
    • Envoy pour les cas avancés (mTLS, HTTP/2/3),
  • pour le cache :
    • Varnish, Apache Traffic Server,
  • favoriser les stacks open-source,
  • utiliser files, buffers, queues et quotas pour lisser les pics.

Références

Comparatif des grandes plateformes cloud

Fonctionnalité Kubernetes OpenStack AWS Bare-metal HPC CRM oVirt
Outils de déploiement Helm, YAML, ArgoCD, Juju Ansible, Terraform, Juju CloudFormation, Terraform, Juju Ansible, Shell xCAT, Clush Ansible, Shell Ansible, Python
Méthode de bootstrap API API, PXE API PXE, IPMI PXE, IPMI PXE, IPMI PXE, API
Contrôle routeur Kube-router Router/Subnet API Route Table / Subnet API Linux, OVS xCAT Linux API
Contrôle firewall Istio, NetworkPolicy Security Groups API Security Group API Linux firewall Linux firewall Linux firewall API
Virtualisation réseau VLAN, VxLAN VPC VPC OVS, Linux xCAT Linux API
DNS CoreDNS DNS-Nameserver Route 53 GDNS xCAT Linux API
Load balancer Kube-proxy, LVS LVS Network Load Balancer LVS SLURM Ldirectord N/A
Stockage Local, cloud, PVC Swift, Cinder, Nova S3, EFS, EBS, FSx Swift, XFS, EXT4, RAID10 GPFS SAN NFS, SAN

Cette table sert de point de départ pour choisir la bonne stack selon :

  • le niveau de contrôle souhaité,
  • le contexte (on-prem, cloud public, HPC…),
  • les outils d’automatisation existants.

Haute disponibilité, HPC & DevSecOps

Haute disponibilité avec Corosync & Pacemaker

HA cluster architecture

Principes :

  • clusters multi-nœuds ou multi-sites,
  • fencing via IPMI,
  • provisioning PXE / NTP / DNS / TFTP,
  • pour 2 nœuds : attention au split-brain,
  • 3 nœuds ou plus recommandés en production.

Ressources fréquentes

  • multipath, LUNs, LVM, NFS,
  • processus applicatifs,
  • IP virtuelles, DNS, listeners réseau.

HPC

Overview of an HPC cluster

  • orchestration de jobs (SLURM ou équivalent),
  • stockage partagé haute performance,
  • intégration possible avec des workloads IA.

DevSecOps

DevSecOps reference design

  • CI/CD avec contrôles de sécurité intégrés,
  • observabilité dès la conception,
  • scans de vulnérabilité,
  • gestion des secrets,
  • policy-as-code.

News & trends

Formation & apprentissage

Liens cloud & IT utiles

Outils collaboratifs

Dépôts de code

Base de connaissance

Messagerie

  • contact interne / support selon les projets

SSO

À propos & contributions

Suggestions de corrections, améliorations de schémas, retours d’expérience ou nouveaux labs bienvenus.

Ce wiki a vocation à rester un laboratoire vivant pour l’IA, le cloud et l’automatisation.

Retrieved from "https://infocepo.com/wiki/index.php?title=Main_Page&oldid=2328"