Main Page

From Essential
Jump to navigation Jump to search
Discover cloud and AI on infocepo.com

infocepo.com – Cloud, AI & Labs

Welcome to the infocepo.com portal.

This wiki documents the Cloud, AI, automation and lab ecosystem of Infocepo. It is intended for:

  • system administrators,
  • cloud engineers,
  • developers,
  • students,
  • curious minds who want to learn by doing.

The goal is simple: transform theory into reusable scripts, diagrams, architectures, APIs, and hands-on labs.


Quick Access

Main Portal

AI Assistant

Wiki Page List

Overview

Infra architecture overview

Getting Started

Recommended Paths

1. Build a private AI assistant
  • Deploy a stack like Hermes WebUI + Ollama + GPU
  • Add a chat model and a summarization model
  • Connect internal data via RAG + embeddings
2. Launch a cloud lab
  • Create a small Kubernetes, OpenStack, or bare-metal cluster
  • Set up a deployment pipeline (Helm, Ansible, Terraform…)
  • Add an AI service: transcription, summarization, chatbot, OCR…
3. Prepare an audit or migration
  • Inventory servers with ServerDiff.sh
  • Design the target architecture
  • Automate the migration with reproducible scripts

Content Overview

  • AI Guides & Tools: assistants, models, evaluation, GPU, RAG
  • Cloud & Infrastructure: Kubernetes, OpenStack, HA, HPC, DevSecOps
  • Labs & Scripts: audit, migration, automation
  • Comparisons: Kubernetes vs OpenStack vs AWS vs bare-metal, etc.

Vision

The world after automation

The long-term goal is to build an environment where:

  • private AI assistants accelerate production,
  • repetitive tasks are automated,
  • deployments are industrialized,
  • infrastructure remains understandable, portable, and reusable.

Every AI output is measured in real time, weak models are automatically replaced, and valueless tasks are cut. Autonomy comes from technical mechanisms that work when no one is watching — not from rules written in a document.

Main page summary

Quick Service Catalog

Main Services
Category Service Role
API LLM Chat, code, RAG, OCR models
API STT Audio transcription
API TTS Speech synthesis
API realtime-ai Real-time WebSocket / WebRTC
API IMAGE2TXT OCR / VLM via dedicated endpoint
API summary Long text summarization
API EMBEDDINGS Embeddings for RAG
API ChromaDB Vector database
API TXT2IMAGE Image generation
API diarization Speaker diarization
Observability monitoring Technical dashboards
Observability status Service availability
Observability web-stat Web statistics
Observability LLM-stat API / usage dashboard
Tools dataLab Non-production work environment
Tools realtime translation Translation
Tools Demos Demonstrators

AI Selection & Layered Architecture

The AI Selection dashboard presents the layered architecture of selected AI models:

Layer Model Alias(es) Size
HYBRID-CLOUD Qwen3.6-35B flash, default, thinking, vision Option 1, 35B MoE / 3B active
Qwen3.8-Flash-Next flash, default, thinking, vision, max Option 2, 125B MoE, 51B internal n-grams, 6B active, 1M context
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-5
Public-Cloud GLM-5.3-Flash max 320B MoE / 18B active — 1M context, 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

Tool Usage
Hermes General purpose, reasoning
OpenCode DevSecOps
Kilo Code Pure development

Memory

For the vector embedding layer (RAG, semantic memory):

  • BGE-M3 — 568M parameters, XLM-RoBERTa architecture. Multi-purpose (dense + sparse + multi-vector), 100+ languages, MIT license. Ideal as a scale-out memory engine.

What's New

Implemented Features

  • translate-rt (2026-11-19) : Real-time translation API — multilingual translation with low latency
  • gouv-fr-skills (2026-11-19) : no GitHub description
  • audio2audio-translate-next (2026-11-17) : no GitHub description
  • api-rag (2026-11-16) : RAG API — semantic search over knowledge bases with retrieval-augmented generation
  • api-txt2image (2026-11-16) : Text-to-image generation API for AI-powered image creation
  • diff-multi (2026-11-07) : Multi-format diff tool — compare files, directories, and structured data
  • gpu-cluster (2026-11-07) : GPU cluster management — k8s-based AI compute cluster with NVIDIA GPUs
  • summarize (2026-11-07) : summary
  • github-k8s-example (2026-11-07) : Kubernetes deployment example for GitHub Actions CI/CD pipelines
  • python2helm (2026-11-07) : Convert Python projects to Helm charts for Kubernetes deployment
  • api-txt2audio (2026-11-07) : Text-to-audio generation API for converting text content to audio output
  • llmbench (2026-11-07) : LLM benchmarking suite — measure and compare language model performance
  • api-realtime-ai (2026-11-07) : Real-time AI inference API with low-latency streaming responses
  • api-ocr (2026-11-07) : Document OCR API — extract text, tables, and structure from scanned documents
  • realtime-transcription (2026-11-07) : Real-time audio transcription service — live speech-to-text
  • k8s-domain-migrate (2026-11-07) : Kubernetes domain migration tool — move services between clusters
  • coder-brain (2026-11-07) : AI-powered code analysis and generation engine
  • k8s-internet-infrastructure (2026-11-07) : Internet infrastructure on Kubernetes — DNS, networking, and routing
  • mail-search (2026-11-07) : Email search tool — query and analyze inbox contents
  • legal-agent (2026-11-07) : Legal AI agent — assist with legal document analysis and research
  • image-editor (2026-11-07) : AI image editor — modify, enhance, and generate images with AI
  • sam-audio (2026-11-07) : ai audio processing
  • ai-security (2026-11-07) : AI security tools — audit and harden LLM deployments against common attacks
  • artificial-human (2026-11-07) : Artificial human simulation — explore the boundary between human and AI behavior
  • mediawiki-migrate (2026-11-07) : MediaWiki migration tool — migrate and sync wiki content between platforms

Top Tasks — Deployed Infrastructure

Generated from real infrastructure (kubectl + LLM endpoints) on 2026-10-03. Do not edit manually — regenerate after deployment.

LLM Endpoints (verified)

Endpoint Real Model URL
ai-thinking qwen3.6 (thinking) https://api-llm-custom.ailab.infocepo.com
ai-default qwen3.6 (default) https://api-llm-custom.ailab.infocepo.com
ai-flash qwen3.6 (fast) https://api-llm-custom.ailab.infocepo.com
ai-vision qwen3.6 (vision/OCR) https://api-llm-custom.ailab.infocepo.com
ai-embedding bge-m3 https://api-embedding.ailab.infocepo.com

AI Services & Infrastructure

Benchmarks & Evaluation

Automated Monitoring

GitHub Monitoring (Popular)

  • unsloth (2026-11-21) : Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more. (79k⭐)
  • LocalAI (2026-11-21) : LocalAI is the open-source AI engine. Run any model - LLMs, vision, voice, image, video - on any hardware. No GPU required. (50k⭐)
  • claude-code-templates (2026-11-21) : Open-source registry and CLI for Claude Code components: agents, commands, skills, hooks, MCPs, settings and mods (34k⭐)
  • vllm (2026-11-20) : A high-throughput and memory-efficient inference and serving engine for LLMs (97k⭐)
  • iFixAi (2026-11-20) : Independent Auditing of AI Agents. Run by human or the agent itself, to answer the most crucial question in the AI Agent Economy. Is the ag… (46k⭐)
  • continue (2026-11-20) : open-source coding agent (36k⭐)
  • posthog (2026-11-19) : :hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session r… (40k⭐)
  • magpie (2026-11-19) : Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar. (38k⭐)
  • onyx (2026-11-19) : Open Source AI Platform - AI Chat with advanced features that works with every LLM (33k⭐)
  • goose (2026-11-18) : an open source, extensible AI agent that goes beyond code suggestions - install, execute, edit, and test with any LLM (56k⭐)
  • multica (2026-11-18) : Make humans and AI agents work as one team — open-source and self-hostable. (56k⭐)
  • cherry-studio (2026-11-18) : Your AI workspace for models, agents, and productivity. (53k⭐)
  • firecrawl (2026-11-17) : Supercharge your AI agents with data from the web and beyond. Building the library for superintelligence. 🔥 (202k⭐)
  • archify (2026-11-17) : Turn any idea, plan, or codebase into a beautiful interactive diagram. An agent skill for Claude Code, Codex, and more. (97k⭐)
  • skills (2026-11-17) : The open agent skills tool - npx skills (39k⭐)
  • browser-use (2026-11-16) : Open-source Python library for AI browser agents, plus Browser Use Cloud: stealth browsers and a hosted agent API. (121k⭐)
  • rtk (2026-11-16) : CLI proxy that reduces LLM token consumption by 60-90% on common dev commands. Single Rust binary, zero dependencies (86k⭐)
  • impeccable (2026-11-15) : The design vocabulary for your coding agent. Steer with polish and bolder, review with critique and audit, catch AI slop before it ships. (110k⭐)
  • chrome-devtools-mcp (2026-11-15) : Chrome DevTools for coding agents (56k⭐)
  • PDFMathTranslate (2026-11-15) : (EMNLP 2025 Demo) PDF scientific paper translation with preserved formats - 基于 AI 完整保留排版的 PDF 文档全文双语翻译,支持 Google/DeepL/Ollama/OpenAI 等服务,提供… (38k⭐)
  • codex (2026-11-14) : Lightweight coding agent that runs in your terminal (135k⭐)
  • hyperframes (2026-11-14) : Write HTML. Render video. Built for agents. (83k⭐)
  • agent-browser (2026-11-14) : Browser automation CLI for AI agents (50k⭐)
  • AutoGPT (2026-11-13) : AutoGPT is the vision of accessible AI for everyone, to use and to build on. Our mission is to provide the tools, so that you can focus on… (188k⭐)
  • supabase (2026-11-13) : The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications. (114k⭐)

Backlog / Technology Monitoring

AI Agents & Orchestration

  • LangChain : Framework for LLM-based applications. Most mature. (145k⭐).
  • Dify : AI application development platform (LLM Ops). Self-hostable. (154k⭐).
  • open-webui : AI web interface (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 : High-performance vector database. (46k⭐).

Audio & TTS

Image Generation & Editing

  • ComfyUI  : Most modular diffusion model GUI and backend. (131k⭐)

RAG & Document Processing

  • paperless-ngx : Document management: scan, index, archive. ML, OCR. (45k⭐).
  • graphify : Transforms codebase into an queryable knowledge graph. (115k⭐).
  • LightRAG : Simple and fast RAG. (39k⭐).
  • graphrag : Graph-based modular RAG. (35k⭐).
  • headroom : Compress tool outputs, logs, files, and RAG chunks. 20-95% token savings. (69k⭐).
  • Mem0 : — Long-term memory for AI agents. (64k⭐).

APIs to Develop

  • AI Classifier — Content classification.
  • Shared Summarizer : Shared text summarization API.
  • NER : Named Entity Recognition.
  • Compressor — Content compression.

Infrastructure & Backend

Dev Tools

  • 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)

AI Assistants & Cloud Tools

AI Assistants

Self-hosted AI Assistants
Typical stack for a private assistant, OpenAI-compatible API, and local experimentation.

Development, Models & Monitoring

Model Discovery
Evaluation & Benchmarks
Development & Fine-tuning Tools

AI Hardware & GPU

  • NVIDIA GH200
  • DGX Spark

Realtime AI API (DEV)

Status: DEV environment, planned replacement for the OpenAI API for real-time use cases.

Configuration

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

GitHub Repository

Test Page

  • external-test/half-duplex.html — echo cancellation + half-duplex mode.

Compatibility

Replace the OpenAI URL with $OPENAI_API_BASE to test compatibility and performance.


LLM API (OpenAI Compatible)

Model List

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

Open Models & Internal Endpoints

Last updated: 2026-10-03

The models below correspond to logical endpoints exposed behind a gateway.

Endpoint Description / Main Usage
ai-thinking qwen3.6 fp8 – thinking
ai-fast qwen3.6 fp8 in fast mode – vision/OCR/ai-default
ai-embedding bge-m3 – semantic search
ai-stt-next nemotron-3.5-asr-streaming-0.6b – multilingual streaming voice transcription
ai-stt whisper3-turbo – multilingual voice transcription
ai-tts OmniVoice – multilingual TTS
ai-image FLUX.2-klein – generate and edit image

Bash Example

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

promptValue="What is your name?"
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 ***" \
  -d "${jsonValue}" 2>/dev/null | jq '.choices[0].message.content'

LLM Infra View

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

DEV (at choice)

  • A. LiteLLM → vLLM/SgLang : performance/compatibility tests
  • B. LiteLLM → Ollama : simple, fast to iterate
  • C. Ollama direct : ultra-lightweight POC

DEV – FR model / summarization

  • LiteLLM → Ollama /v1

PROD

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

Notes:

  • LiteLLM = single gateway (keys, quotas, logs)
  • vLLM/SgLang = performance / stability under load
  • Ollama = prototyping simplicity

API Image to Text

  • Uses the LLM API with an endpoint suited for OCR / VLM.
  • Recommended model: ai-vision

Bash Example

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": "Describe this image." },
          {
            "type": "image_url",
            "image_url": { "url": ("data:image/png;base64," + ($img | rtrimstr("\n"))) }
          }
        ]
      }
    ]
  }' > payload.json

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

Python Example

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-llm-custom.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": "Describe this 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"Error {response.status_code}: {response.text}")

API STT

Python Example

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())

Curl Example

[ ! -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 ***" \
  -F model="whisper-1" \
  -F file="/tmp/test.ogg"

Notes

  • Multiple audio formats are accepted.
  • The final stream is normalized to 16 kHz mono.
  • For optimal quality: prefer OPUS 16 kHz mono.

UI


API TTS

Example

export OPENAI_API_KEY=sk-XXXXX

curl https://api-tts-omnivoice.ailab.infocepo.com/v1/audio/speech \
  -H "Authorization: Bearer ***" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o-mini-tts",
    "input": "Hello, this is a speech synthesis test.",
    "voice": "coral",
    "instructions": "Speak in a cheerful and positive tone.",
    "response_format": "opus"
  }' | ffplay -i -

API Text to Image

Example

export OPENAI_API_KEY=EMPTY

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

API Diarization

Example

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 ***" \
  -F "file=/tmp/test.mp3"

API Summary

Example

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

Example

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'

Vector DB API (ChromaDB)

Production

Lab

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

Curl Example

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

Python Example

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)

Deploy Your Own 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"}]'

Retrieve the Token

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

Registry

Example

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

K8S Example

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"}]}}}}'

External Object Storage (S3)

A bucket named ORG has been created to store demonstration documents.


RAG Optimization

  • Embeddings: BAAI/bge-m3
  • chunk_size=1000
  • chunk_overlap=100
  • LLM: qwen3.6
  • For mixed PDFs: PDF → image → OCR / VLM can improve results.

Workflow

Direct route: code → CI/CD → deploy → monitoring. No committee, no designated manager — each step triggers automatically if the previous one passes. If it fails, direct alert without involving a human unless explicit fallback decision is made.


Environments

Non-production

  • Use datalab
  • Support: Mattermost Offre IA channel
  • The user pseudonym must follow internal conventions
  • Request Linux + Kubernetes access if needed

Production (best-effort)

  • Publish application code, secrets (SOPS format), Dockerfile, and infrastructure code (Helm or K8S manifests) to Git
  • Request a namespace
  • Read the associated monitoring documentation

Infrastructure Limits

  • GPU workloads are intentionally limited during business hours.
  • Unit cost is measured automatically (real-time dashboards, not Excel).

Cloud Lab & Audit Projects

Cloud Lab reference diagram

The Cloud Lab provides reproducible scenarios: infrastructure audit, cloud migration, automation, high availability.

Audit Project

ServerDiff.sh

Bash audit script enabling:

  • detection of configuration drift,
  • comparison of multiple environments,
  • preparation of a migration or remediation plan.

Cloud Migration Example

Cloud migration diagram

Task Description Duration (days)
Infrastructure Audit 82 services, automated audit via ServerDiff.sh 1.5
Architecture Diagram Visual design and documentation 1.5
Compliance Checks 2 clouds, 6 hypervisors, 6 TB RAM 1.5
Cloud Platform Installation Deployment of target environments 1.0
Stability Verification First functional tests 0.5
Automation Study Identification of repetitive tasks 1.5
Template Development 6 templates, 8 environments, 2 clouds / OS 1.5
Migration Diagram Illustration of the process 1.0
Migration Code Writing 138 lines (see MigrationApp.sh) 1.5
Stabilization Reproducibility validation 1.5
Cloud Benchmark Comparison vs legacy 1.5
Downtime Tuning Downtime calculation 0.5
VM Loading 82 VMs: OS, code, 2 IP per VM 0.1
Total 15 man-days

Stability Checks (Minimal HA)

Action Expected Result
Node shutdown All services automatically restart on other nodes
Simultaneous shutdown / restart of all nodes Services restart correctly after reboot


Autonomy tested: verify that the migration works by itself by pulling the repo and running the script, without anyone who knows the system being present.


Web Architecture & Best Practices

Reference web architecture

Design principles:

  • prefer simple, modular, and flexible infrastructure,
  • bring content closer to the client (GDNS or equivalent),
  • use network load balancers (LVS, IPVS),
  • compare costs and avoid vendor lock-in,
  • for TLS:
    • HAProxy for fast frontends,
    • Envoy for advanced cases (mTLS, HTTP/2/3),
  • for caching:
    • Varnish, Apache Traffic Server,
  • favor open-source stacks,
  • use files, buffers, queues, and quotas to smooth out peaks.

References


Major Cloud Platform Comparison

Feature Kubernetes OpenStack AWS Bare-metal HPC CRM oVirt
Deployment Tools Helm, YAML, ArgoCD, Juju Ansible, Terraform, Juju CloudFormation, Terraform, Juju Ansible, Shell xCAT, Clush Ansible, Shell Ansible, Python
Bootstrap Method API API, PXE API PXE, IPMI PXE, IPMI PXE, IPMI PXE, API
Router Control Kube-router Router/Subnet API Route Table / Subnet API Linux, OVS xCAT Linux API
Firewall Control Istio, NetworkPolicy Security Groups API Security Group API Linux firewall Linux firewall Linux firewall API
Network Virtualization 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
Storage Local, cloud, PVC Swift, Cinder, Nova S3, EFS, EBS, FSx Swift, XFS, EXT4, RAID10 GPFS SAN NFS, SAN

This table serves as a starting point for choosing the right stack based on:

  • the level of control desired,
  • the context (on-prem, public cloud, HPC…),
  • existing automation tools.

High Availability, HPC & DevSecOps

High Availability with Corosync & Pacemaker

HA cluster architecture

Principles:

  • multi-node or multi-site clusters,
  • fencing via IPMI,
  • PXE / NTP / DNS / TFTP provisioning,
  • for 2 nodes: watch out for split-brain,
  • 3 nodes or more recommended in production.

Frequent Resources

  • multipath, LUNs, LVM, NFS,
  • application processes,
  • virtual IPs, DNS, network listeners.

HPC

Overview of an HPC cluster

  • job orchestration (SLURM or equivalent),
  • high-performance shared storage,
  • possible integration with AI workloads.

DevSecOps

DevSecOps reference design

  • CI/CD with built-in security controls,
  • observability by design,
  • vulnerability scanning,
  • secret management,
  • policy-as-code.

News & Trends


Training & Learning


Useful Cloud & IT Links


Collaborative Tools

Code Repositories

Knowledge Base

Messaging

  • internal contact / support per project

SSO


About & Contributions

Suggestions for corrections, diagram improvements, experience returns, or new labs are welcome.

This wiki aims to remain a living laboratory for AI, cloud, and automation.