🚀 Scaleway – The European Cloud (Écosystème & Services)

Modèle d'Isolation (Hierarchie)

• Organization : Billing Root. Lié au SIRET/VAT. Propriétaire des Users.
• Project : Boundary technique stricte.
  • VPC Dédié : Chaque projet a son propre VLAN L2 isolé.
  • Quotas : Limites vCPU/RAM/GPU spécifiques par projet.
  • IAM Scope : Les droits s'appliquent au niveau Projet (ou Orga).

IAM & Secret Management

• Principals : Users (Humains) vs Applications (API Keys pour CI/CD).
• Policies : JSON Rules. Ex: ObjectStorageReadOnly, InstancesFullAccess.
• Secret Manager : Vault managé. Versioning des secrets. Intégration K8s via External Secrets Operator.

Architecture VPC (Private Network)

Le VPC Scaleway est régional (Multi-AZ). C'est un Layer 2 étendu.

                            # Exemple Terraform VPC + Gateway
                            resource "scaleway_vpc_private_network" "pn" { name = "private-network" }
                            resource "scaleway_vpc_public_gateway" "pgw" { type = "VPC-GW-M" } # 2Gbps
                            resource "scaleway_vpc_gateway_network" "main" {
                            gateway_id = scaleway_vpc_public_gateway.pgw.id
                            private_network_id = scaleway_vpc_private_network.pn.id
                            enable_dhcp = true
                            }
                        

Compute Specs (Instances & Metal)

Storage & Data Technologies

• Block Storage (SBS) :
  • IOPS : 5,000 (Basic) à 15,000 (High Speed).
  • Latence : < 1ms (NVMe over Fabric).
  • Features : Resize à chaud, Snapshots instantanés (CoW), Unmount/Move.
• Object Storage (S3) :
  • Standard : Multi-AZ (Erasure Code 4+2). 99.9999999% Durabilité.
  • OneZone-IA : Mono-AZ. Moins cher (-20%).
  • Glacier (C14) : Archivage froid sur hardware dédié. Restore time variable.
• Managed DB (RDB) : PostgreSQL 15+, MySQL 8. Extension pgvector supportée pour RAG/IA. Backup WAL archivés sur S3.

Modèle de Pricing & Capping

Scaleway applique un modèle de facturation horaire plafonné ("Monthly Cap").

Ecosystème & Outils DevOps

• Terraform : Provider scaleway/scaleway. Couverture > 95% des services. State stockable sur Object Storage (avec Locking).
• Cockpit (Observability) : Stack Grafana/Loki/Mimir managée.
  • Push Metrics via Prometheus Remote Write.
  • Alertmanager intégré pour notifications (Slack/Email/Webhook).
• Serverless :
  • Functions (Go, Python, Node) et Containers (Knative).
  • Scale-to-zero (0€ si pas de requête).

VPC (Virtual Private Cloud) Specs

• Technologie : Layer 2 étendu (VLAN). Isolation totale.
• Portée : Régionale (Multi-AZ). Une VM en PAR-1 voit une VM en PAR-2 sur le même subnet.
• Adressage : DHCP Managé par Scaleway. Baux statiques possibles.
• Interfaces : Support du Multi-NIC (jusqu'à 8 Private Networks par instance).

Public Gateway (NAT)

Routeur virtuel haute dispo pour l'accès Internet sortant (SNAT).

Load Balancer (Regional)

• Architecture : Proxy managé Haute Dispo. IP Anycast (failover auto).
• Protocols : TCP (L4), HTTP/HTTPS (L7). Support HTTP/2 et WebSocket.
• SSL : Let's Encrypt Wildcard géré automatiquement ou Certificat Custom.
• Private LB : Possibilité de ne pas exposer d'IP Publique (Internal LB).

                            # Architecture Réseau Typique (Terraform style)
                            resource "scaleway_vpc_private_network" "main" {
                            name = "prod-network-192-168"
                            }

                            resource "scaleway_vpc_public_gateway_ip" "gw_ip" {}

                            resource "scaleway_vpc_public_gateway" "main" {
                            name  = "prod-gateway"
                            type  = "VPC-GW-M" # 2Gbps
                            ip_id = scaleway_vpc_public_gateway_ip.gw_ip.id
                            }

                            resource "scaleway_vpc_gateway_network" "main" {
                            gateway_id         = scaleway_vpc_public_gateway.main.id
                            private_network_id = scaleway_vpc_private_network.main.id
                            enable_dhcp        = true
                            enable_masquerade  = true # SNAT activé
                            }
                        

Modèle Hiérarchique

• Organization : Entité de facturation (Root).
  • Propriétaire légal des ressources.
  • Gestion des Utilisateurs & Groupes IAM.
• Project : Boundary d'isolation technique.
  • Réseau : 1 Projet = 1 VPC par défaut (pas de routing inter-projet natif).
  • IAM : Les droits sont scopés par Projet (ex: User A est Admin sur Projet Dev, mais Viewer sur Projet Prod).
  • Quotas : Limites de ressources (vCPU, RAM, GPU) définies par Projet.

Stratégie d'Isolation (Best Practices)

• Environment Isolation :
  Créer un projet distinct pour Development, Staging, et Production.
  Avantage : Impossible de supprimer la DB de Prod par erreur depuis un script de Dev.
• Network Boundary :
  Le VPC ne traverse pas les projets. Pour relier deux projets, il faut passer par :
  • Public Internet (avec Whitelist IP).
  • VPN (Instance à Instance).
  • VPC Peering (Feature en Beta/Roadmap).

Elastic Metal (Cloud Native Bare Metal)

Serveurs physiques 100% dédiés, intégrés au VPC, facturés à l'heure.

Elastic Metal vs Dedibox

• Elastic Metal :
  • Pilotable via API Scaleway Elements (Terraform).
  • Intégré au Private Network (VPC) L2.
  • Facturation horaire possible.
• Dedibox (Legacy) :
  • Console séparée (console.online.net).
  • Engagement mensuel + Frais install.
  • Réseau RPN (Incompatible VPC sauf via passerelle).

GPU Instances (AI & Rendering)

Pas de vGPU partagé. Pass-through direct.

Apple Silicon (Mac as a Service)

• Hardware : Mac Mini M1 (8GB) ou M2 Pro (32GB).
• OS : macOS Sonoma / Ventura. Accès VNC ou SSH.
• Contrainte Licence Apple : Location minimale de 24 heures imposée.
• Réseau : IP Publique uniquement (Pas de VPC privé).

Kapsule (Managed K8s)

• Control Plane : Gratuit (Mutualisé) ou Dédié (High SLA).
• CNI : Cilium (eBPF) par défaut, Calico, Weave.
• CSI : Block Storage (RWO) et Object Storage (RWX via s3-fuse, perf limitée).
• Autoscaling : Cluster Autoscaler supporté. Node pools mixtes (Instances + Metal).
• Ingress : Intégration native avec Load Balancer Scaleway + CertManager.

Kosmos & Serverless

• Kosmos (Multi-Cloud) :
  • Control Plane chez Scaleway.
  • Worker Nodes n'importe où (AWS, GCP, On-Prem).
  • Tunneling VPN managé transparent.
• Serverless Containers :
  • Basé sur Knative.
  • Scale-to-zero (0 instance = 0€).
  • Images Docker custom. Limitation : Stateless, 15min timeout.

Scaleway Block Storage (SBS)

Volumes persistants NVMe-over-Fabric. Détachables et redimensionnables.

• Unified Snapshots : Les snapshots sont stockés sur Object Storage (Zonal ou Multi-AZ).
• Boot-on-Block : Toutes les instances (sauf Metal) bootent sur ces volumes.

Opérations Disque (Lifecycle)

• Hot Resize : Augmentation de taille sans reboot (nécessite resize2fs côté OS).
• Hot Detach : Déplacer un volume de data d'une instance A vers B en quelques secondes.
• Local Storage (Scratch) :
  • Dispo uniquement sur gammes ENT1 et H100.
  • Performance extrême (NVMe direct) mais éphémère (perdu au stop).

Managed Databases (RDB)

• Moteurs : PostgreSQL (13-16), MySQL 8.
• Architecture HA : Active/Standby avec IP Failover auto (bascule < 60s).
• Storage Scaling : Auto-extension du volume Block Storage si plein.
• Extensions : PostGIS (Géo), TimescaleDB (Time-series), pgvector (AI/Embeddings).

Backup & Retention

• Automated Backups : Quotidien. Rétention configurable (jusqu'à 365 jours sur demande, 7 par défaut).
• PITR (Point-In-Time Recovery) : Restauration à la seconde près (via WAL logs).
• Snapshots Manuels : Possible avant une mise en prod risquée.
• Export : Dump direct vers bucket S3.

CLI & Compatibilité S3

L'API étant standard, utilisez les outils de l'écosystème AWS.

                            # AWS CLI (Config profile)
                            aws configure set plugins.endpoint awscli_plugin_endpoint
                            aws s3 ls --endpoint-url https://s3.fr-par.scw.cloud

                            # Rclone (Le couteau suisse)
                            rclone sync /local/data scw:my-bucket --transfers 16

                            # s3cmd
                            s3cmd mb s3://new-bucket
                        

Pricing FinOps (Est. 2025)

• Object Storage :
  • Stockage : ~0.013 €/GB/mois (Standard).
  • Transfert Sortant : ~0.01 €/GB (après 75GB offerts).
  • Requêtes : Gratuites ou très faibles (vs AWS).
• Block Storage :
  • ~0.08 €/GB/mois (inclut la performance IOPS).

Public Gateway (NAT & Bastion)

Appliance managée pour fournir l'accès Internet (SNAT) aux ressources privées.

Fonctionnalités Clés

• Mode HA : Déploiement redondant multi-AZ disponible (IP failover auto).
• Bastion SSH : Serveur bastion managé intégré (accès via clé SSH configurée dans l'IAM).
• IP Statique : L'IP de sortie est fixe (utile pour whitelisting chez des partenaires).

                            # Terraform: Attacher une Gateway à un réseau privé
                            resource "scaleway_vpc_gateway_network" "main" {
                            gateway_id         = scaleway_vpc_public_gateway.pgw.id
                            private_network_id = scaleway_vpc_private_network.pn.id
                            enable_masquerade  = true  # Active le NAT
                            enable_dhcp        = true  # Le GW agit comme serveur DHCP
                            }
                        

Cloud Load Balancer (Multi-AZ)

• Type : Layer 4 (TCP) et Layer 7 (HTTP/HTTPS/HTTP2).
• Architecture : Proxy inverse haute dispo basé sur Nginx/Haproxy custom. IP Anycast.
• SSL/TLS :
  • Termination ou Passthrough.
  • Certificats Let's Encrypt gérés et renouvelés automatiquement.
• Santé : Health Checks TCP, HTTP (codes 2xx-4xx), MySQL, PGSQL, Redis.
• Sticky Sessions : Basé sur cookie (L7) ou source IP (L4).

Kubernetes Ingress Controller

Intégration native via k8s-cloud-controller-manager.

                            apiVersion: v1
                            kind: Service
                            metadata:
                            annotations:
                            # Use specific LB IP
                            service.beta.kubernetes.io/scw-loadbalancer-ip-id: "xxx-xxx"
                            # Enable Proxy Protocol v2 (pour récupérer l'IP client réelle)
                            service.beta.kubernetes.io/scw-loadbalancer-proxy-protocol-v2: "true"
                            # Force redirect HTTP -> HTTPS
                            service.beta.kubernetes.io/scw-loadbalancer-force-ssl-redirect: "true"
                            spec:
                            type: LoadBalancer
                        

Domains & DNS

• Registrar : Extensions .fr, .com, .net, .io, .ai, etc.
• DNS Zones : Support Anycast. API complète pour records automation (ACME DNS-01 challenge).
• Import : Supporte l'import de zone files BIND.

IP Failover (Elastic IP)

Crucial pour la HA sur Elastic Metal et Dedibox.

• Permet de router une IP publique (/32) vers n'importe quel serveur du compte.
• Bascule via API en < 30 secondes.
• Support du VRRP (Keepalived) pour bascule automatique.

IPAM & Addressing

• Flexible IPs : Les IPs publiques (Instances, LB, GW) sont détachables et conservables.
• IPv6 :
  • IPv6 /128 par défaut sur les Instances.
  • SLAAC supporté sur les réseaux privés.
• Mac Address : Persistante sur Elastic Metal. Virtuelle sur Instances (gérée par KVM).

Managed Redis™

• Modes :
  • Standalone : Instance unique. Cache simple.
  • Cluster : Sharding (3+ nodes). Haute dispo et distribution de charge.
• Versions : Redis 6, 7.
• Sécurité : Support ACL (Access Control List) et TLS (Transit Encryption).
• Persistance : Optionnelle (AOF / RDB) pour durabilité des données.

Opensearch & Document DB

• Managed Opensearch :
  • Fork open-source d'Elasticsearch.
  • Stack ELK complète (Dashboards inclus).
  • Usage : Centralisation de logs, Recherche Full-text.
• FerretDB (Managed) :
  • Proxy compatible MongoDB fonctionnant sur un backend PostgreSQL.
  • Permet d'utiliser les drivers Mongo avec la robustesse de PG.

Messaging & Queuing (Serverless)

Intégration Event-Driven

• Déclencher des Serverless Functions ou Containers à chaque message (Trigger).
• Fan-out pattern : Un message SNS vers plusieurs Queues SQS ou endpoints HTTP.
• Retention : Configurable (ex: 7 jours pour SQS).
• Dead Letter Queue (DLQ) : Gestion des messages en erreur.

Vector Database (RAG & LLM)

Indispensable pour fournir de la mémoire (contexte) aux modèles d'IA générative (RAG).

• pgvector (sur Managed PostgreSQL) :
  • Extension open-source standard.
  • Stockage des embeddings directement à côté des données relationnelles.
  • Indexation IVFFlat ou HNSW pour recherche de similarité rapide.
• Qdrant (Managed Partner) :
  • DB vectorielle native haute performance (Rust).
  • Filtrage avancé et scaling horizontal.

Architecture RAG Typique

                            1. Ingestion : PDF/Text -> Chunks -> Embeddings (via H100/L40S).
                            2. Stockage : Embeddings -> PostgreSQL (pgvector).
                            3. Query : User Prompt -> Embedding -> SELECT ... ORDER BY distance.
                            4. Generation : Contexte + Prompt -> LLM (Mistral sur H100).
                        

Cloud Functions (FaaS)

• Runtimes supportés :
  • Python (3.7 - 3.11)
  • Node.js (14 - 20)
  • Go (1.18 - 1.21)
  • PHP, Rust (Beta)
• Architecture : Code zippé injecté dans un runtime géré. Handler spécifique par langage.
• Cold Start : Variable selon la taille du bundle et le langage (Go/Rust plus rapides que Node/Python).

Handler Example (Python)

                            def handle(event, context):
                            """
                            event: dict contenant body, headers, query
                            context: info sur l'execution
                            """
                            print(f"Processing event: {event}")
                            return {
                            "body": {"message": "Hello from Scaleway"},
                            "statusCode": 200
                            }
                        

Serverless Jobs

Exécution de tâches longues (Batch) sans contrainte de timeout HTTP.

• Différence vs Containers : Asynchrone. Pas de port d'écoute. S'arrête quand le processus exit(0).
• Limites : Jusqu'à 24 heures d'exécution (vs 15 min pour Containers).
• Ressources : Jusqu'à 16 vCPU / 32 GB RAM (High Performance).
• Usage : Entraînement IA léger, ETL Data, Rendu vidéo, Database migration.

Event-Driven Triggers

Limites & Constraints

• Timeout HTTP : Max 900s (15 minutes). Pour plus long -> Serverless Jobs.
• Payload : Max 6MB (Body request/response).
• Disque : Ephemeral /tmp (512MB à 1GB selon profil). Pas de persistance.
• Logs : Streamés vers Cockpit (Grafana/Loki).

Pricing & Frameworks

• Free Tier :
  • 400 000 GB-s de compute offerts / mois.
  • 300 000 Invocations offertes / mois.
• Outils IaC :
  • Terraform : scaleway_function, scaleway_container.
  • Serverless Framework : Plugin serverless-scaleway-functions.

Security Groups (Firewall)

Firewall Stateful appliqué au niveau de l'interface virtuelle de l'instance.

Stateful = Le trafic retour d'une connexion établie est autorisé automatiquement.

Bastion & Isolation

• Managed Bastion :
  • Point d'entrée SSH sécurisé et audité vers les réseaux privés.
  • Plus besoin de maintenir une instance "jumphost" vulnérable.
• Private Network Isolation :
  • Les VLANs sont étanches. Pas de communication entre VPC A et VPC B sans gateway.
• SMTP Ports : Le port 25 est bloqué par défaut sur les instances (anti-spam) sauf déblocage via KYC.

Secret Manager

• Fonction : Stockage sécurisé de credentials (DB password, API keys, Certificats).
• Versioning : Historique des versions de secrets (v1, v2, latest).
• Accès : API REST / gRPC. Intégration IAM.

                            # Récupération (Runtime)
                            scw secret version access $SECRET_ID revision=latest

                            # Intégration K8s (External Secrets Operator)
                            apiVersion: external-secrets.io/v1beta1
                            kind: ExternalSecret
                            spec:
                            data:
                            - secretKey: db-pass
                            remoteRef:
                            key: id:xxxx-xxxx
                            version: latest
                        

Key Management Service (KMS)

• HSM : Clés stockées dans des modules matériels sécurisés.
• Usage :
  • Chiffrement de Buckets S3 (Server-Side Encryption).
  • Chiffrement de Volumes Block Storage (LUKS automation).
  • Signature numérique.
• Rotation : Rotation automatique des clés configurable.

Protection Anti-DDoS (Arbor)

Inclus par défaut sur toutes les IPs publiques Scaleway.

• Detection : Analyse comportementale du trafic en temps réel.
• Mitigation :
  • Filtrage Volumétrique (L3/L4) automatique.
  • Capacité d'absorption massive via le backbone Iliad.
• Advanced : Protection DDoS Applicative (L7) disponible via WAF partenaire ou configuration custom sur LB.

Compliance & Certifications

Push Metrics (Prometheus)

Configuration du remote_write pour envoyer vos métriques locales vers Cockpit.

                            # prometheus.yml
                            remote_write:
                            - url: "https://metrics.cockpit.fr-par.scw.cloud/api/v1/push"
                            headers:
                            X-Token: "$SCW_SECRET_KEY"
                        

Push Logs (Promtail / Fluentd)

                            # promtail.yaml
                            clients:
                            - url: https://logs.cockpit.fr-par.scw.cloud/loki/api/v1/push
                            tenant_id: "$SCW_PROJECT_ID"
                            basic_auth:
                            username: "$SCW_ACCESS_KEY"
                            password: "$SCW_SECRET_KEY"
                        

Tokens & Sécurité

• Token : Génération de Tokens dédiés à Cockpit (différents des clés API IAM) pour isoler les droits d'écriture (Push) et de lecture (Query).
• Datasources : Dans Grafana, les datasources (Loki/Mimir) sont pré-configurées automatiquement.
• Global Endpoint : Points d'ingestion régionaux (PAR/AMS/WAW) pour réduire la latence.

Managed Alerting (Alertmanager)

• Définition des règles d'alerte en YAML (Mimir rules) ou via l'interface Grafana.
• Contact Points :
  • Email, Slack, Discord, PagerDuty, OpsGenie.
  • Webhooks génériques (pour trigger une Cloud Function).
• Grouping : Regroupement des alertes pour éviter le spam (deduplication).

Exemple de Règle (PromQL)

• Les alertes sont évaluées côté serveur (Mimir), pas dans le navigateur.

Modèle de Pricing

Facturation à l'usage (Pay-as-you-go) basée sur le volume.

Rétention des Données

• Custom Retention : Configurable par type de données (ex: garder les Metrics 12 mois, les Logs 30 jours).
• Impact Coût : Le stockage long terme a un coût additionnel (faible, basé sur Object Storage en backend).
• Free Tier : Cockpit inclut un quota mensuel gratuit généreux pour les petits projets (ex: 75 Mo logs, X millions metrics).

Scaleway CLI (scw)

Binaire Go unique, sans dépendance. Auto-complétion Bash/Zsh.

Snippets Utiles

                            
                            # 1. Créer une instance et récupérer son IP publique (JSON parsing)
                            IP=$(scw instance server create type=PLAY2-NANO image=ubuntu_jammy -o json | jq -r .public_ip.address)

                            # 2. Lister les IDs des nodes Kapsule
                            scw k8s node list cluster-id=$CLUSTER_ID -o template='{{range .}}{{ .Name }} : {{ .ID }}{{"\n"}}{{end}}'

                            # 3. Login Docker Registry
                            scw registry login
                            
                        

Packer (Golden Images)

• Builder : scaleway.
• Workflow : Snapshot d'une instance -> Création d'une Image privée.
• Usage : Pré-installer Docker, Agents de monitoring, Durcissement OS (CIS Benchmarks).

                            source "scaleway" "ubuntu" {
                            access_key      = "${var.scw_access_key}"
                            secret_key      = "${var.scw_secret_key}"
                            project_id      = "${var.scw_project_id}"
                            zone            = "fr-par-1"
                            image           = "ubuntu_jammy"
                            commercial_type = "PLAY2-NANO"
                            ssh_username    = "root"
                            snapshot_name   = "golden-image-"
                            }
                        

Ansible (Configuration Mgmt)

• Collection : scaleway.scaleway (Galaxy).
• Dynamic Inventory : Récupération automatique des hosts basée sur les tags API.

                            # my_scaleway_inventory.yml
                            plugin: scaleway.scaleway.scaleway_inventory
                            regions:
                            - fr-par
                            tags:
                            - "env:prod"
                            groups:
                            web_servers: "'role:web' in tags"
                            db_servers: "'role:database' in tags"
                        

SDKs Officiels

• Go : github.com/scaleway/scaleway-sdk-go (Base de la CLI et Terraform).
• Python : pip install scaleway-sdk (Typé, Async support).
• JS/TS : @scaleway/sdk.

API Automation

API REST standard. Auth via Header X-Auth-Token.

Exemple Python SDK

                            from scaleway.apis import instance_v1
                            from scaleway import Client

                            client = Client.from_config_file_and_env()
                            api = instance_v1.API(client)

                            # List servers in PAR-1
                            servers = api.list_servers(zone="fr-par-1")
                            for s in servers.servers:
                            print(f"{s.name} - {s.public_ip.address}")
                        

• Rate Limiting : Respecter les quotas API (ex: pas de polling agressif, utiliser les webhooks ou Events si possible).

Legacy to Cloud Bridge

Connectez vos serveurs Dedibox (réseau RPN) à votre VPC Scaleway Elements.

• Principe : VLAN Cross-Connect physique au sein des datacenters DC2/DC3.
• Performance : Connectivité L2 privée, débit ligne (1Gbps à 10Gbps selon offre).
• Isolation : Le trafic ne passe PAS par Internet. Latence < 1ms.

Configuration

• Pré-requis : Avoir un compte Dedibox (console.online.net) et un compte Scaleway (console.scaleway.com) liés.
• Activation : Via la console, commander l'interconnexion RPN v2 <-> VPC.
• Usage :
  • Database massive sur Dedibox (Stockage pas cher).
  • Frontend K8s Kapsule sur Scaleway (Scalabilité).

VPN Gateway

• Pour relier un bureau/DC On-Prem au VPC Scaleway via Internet.
• Architecture : Utiliser 2 instances (VM) configurées en Gateway VPN (StrongSwan / WireGuard) derrière un Load Balancer UDP.
• Managed ? Pas encore de "Cloud VPN" managé natif (Roadmap). Il faut gérer l'instance VPN ou utiliser une Public Gateway en mode Bastion/VPN.

Private Peering (Direct Connect)

• Scaleway Datacenter Connect :
  • Lien fibre physique direct (Cross-Connect) dans les MMR (Meet-Me-Room) des datacenters (Equinix, Interxion, Telehouse).
  • Débit : 1 Gbps ou 10 Gbps dédié.
  • Idéal pour : Latence stable, sécurité bancaire, gros volumes de données.

Pattern: Data Sovereignty

• Données Sensibles : Stockées sur Elastic Metal (Disques chiffrés, contrôle physique total).
• Traitement : Effectué par des Serverless Functions ou K8s qui lisent/écrivent via le Private Network.
• Avantage : Compliance stricte (isolation hardware) + Flexibilité Cloud.

Pattern: Edge AI Inference

• Training : Sur Scaleway H100 Superpod (Puissance max).
• Model Registry : Stockage des poids du modèle sur Object Storage.
• Inference : Déploiement sur des nœuds Kosmos situés en Edge (Usines, Magasins) pour latence zéro.

AWS CLI Config (~/.aws/config)

Scaleway S3 est compatible. Utilisez un alias pour gagner du temps.

                            # ~/.aws/config
                            [profile scw]
                            region = fr-par
                            output = json
                            s3 =
                            endpoint_url = https://s3.fr-par.scw.cloud
                            signature_version = s3v4
                            max_concurrent_requests = 100
                            max_queue_size = 1000

                            # ~/.aws/credentials
                            [scw]
                            aws_access_key_id = $SCW_ACCESS_KEY
                            aws_secret_access_key = $SCW_SECRET_KEY
                        

Rclone Config (High Perf Copy)

                            # rclone config (choisir "s3", provider "Scaleway")
                            [scw]
                            type = s3
                            provider = Scaleway
                            access_key_id = $ACCESS_KEY
                            secret_access_key = $SECRET_KEY
                            region = fr-par
                            endpoint = s3.fr-par.scw.cloud
                            acl = private

                            # Sync Command
                            rclone sync /local/data scw:my-bucket --transfers 16 --progress
                        

Base Provider & Backend

                            terraform {
                            required_providers {
                            scaleway = { source = "scaleway/scaleway" }
                            }
                            backend "s3" {
                            bucket   = "tfstate-infra"
                            key      = "prod.tfstate"
                            region   = "fr-par"
                            endpoint = "https://s3.fr-par.scw.cloud"
                            skip_credentials_validation = true
                            skip_region_validation      = true
                            }
                            }

                            provider "scaleway" {
                            zone   = "fr-par-1"
                            region = "fr-par"
                            }
                        

Common Resources

                            # VPC & Gateway
                            resource "scaleway_vpc_private_network" "pn" {}
                            resource "scaleway_vpc_public_gateway" "pgw" { type = "VPC-GW-M" }

                            # Instance
                            resource "scaleway_instance_server" "web" {
                            type  = "PRO2-S"
                            image = "ubuntu_jammy"
                            tags  = ["prod"]
                            private_network { pn_id = scaleway_vpc_private_network.pn.id }
                            }

                            # K8s Cluster
                            resource "scaleway_k8s_cluster" "k8s" {
                            name    = "k8s-prod"
                            version = "1.28"
                            cni     = "cilium"
                            }
                        

Security & Access

• Isolation : Prod et Staging sont dans des Projets distincts.
• IAM : Pas de clé API avec droits "Admin" utilisée dans la CI/CD.
• Network : Security Groups en "Drop Inbound" par défaut.
• SSH : Bastion managé utilisé, port 22 fermé au public.

Reliability & FinOps

• Backups : Snapshots automatiques activés sur les Instances et DB.
• Monitoring : Cockpit activé, Alerting configuré (CPU > 90%, Error Rate).
• Haute Dispo : Ressources réparties sur au moins 2 AZ (ex: par-1 et par-2).
• Budgets : Alertes de facturation configurées (ex: alerte à 50% et 80% du budget).