Guide complet : Configuration de Scaleway Object Storage avec Dokploy pour votre projet Laravel/Nuxt

Avant-propos

Dans le paysage actuel du développement web, le choix de l'infrastructure de stockage est une décision stratégique qui impacte directement la performance, la sécurité, la scalabilité et les coûts opérationnels de votre application.

Ce guide détaillé vous accompagne à travers l'ensemble du processus de configuration d'une solution de stockage d'objets professionnelle utilisant Scaleway Object Storage couplé à Dokploy, la plateforme de déploiement open-source. Nous aborderons non seulement les aspects techniques, mais également les enjeux stratégiques qui justifient ce choix.

Contexte du projet

Notre architecture repose sur :

• Laravel pour l'API backend, exploitant les dernières fonctionnalités du framework

• Nuxt / Vue.js pour le frontend, offrant une expérience utilisateur réactive et moderne

• PostgreSQL comme système de gestion de base de données relationnelle

• FrankenPHP comme serveur applicatif haute performance

• Dokploy comme plateforme de déploiement et d'orchestration

• Hostinger VPS KVM2 comme infrastructure de base (Ubuntu)

• Scaleway Object Storage comme solution de stockage de médias et de sauvegardes

Sommaire détaillé

1. Contexte et enjeux stratégiques

2. Analyse comparative des solutions de stockage cloud

3. Pourquoi Scaleway Object Storage ?

4. Architecture de la solution

5. Prérequis et préparation

6. Création du bucket Object Storage

7. Génération et gestion des clés API

8. Configuration des permissions IAM

9. Configuration de la destination S3 dans Dokploy

10. Résolution détaillée des erreurs courantes

11. Intégration avec Laravel

12. Configuration des sauvegardes automatiques

13. Sécurité et bonnes pratiques

14. Performances et optimisation

15. Surveillance et monitoring

16. Conclusion et perspectives

Contexte et enjeux stratégiques

La problématique du stockage dans les applications web modernes

Une application web moderne manipule une quantité croissante de données non structurées :

• Images et vidéos uploadées par les utilisateurs

• Fichiers générés par l'application (exports, rapports)

• Sauvegardes de bases de données

• Logs et traces d'activité

• Assets statiques (CSS, JavaScript, polices)

Ces données doivent être :

1. Accessibles : à faible latence depuis n'importe quel point du globe

2. Durables : protégées contre la perte et la corruption

3. Scalables : capables d'absorber une croissance exponentielle

4. Sécurisées : avec des contrôles d'accès granulaires

5. Économiques : avec un coût total de possession maîtrisé

Les spécificités du contexte camerounais

Notre application cible une audience principalement basée au Cameroun et en Afrique de l'Ouest. Cette particularité géographique impose des contraintes spécifiques :

• Latence réseau : Les infrastructures cloud américaines (AWS us-east-1, us-west-2) génèrent des temps de réponse élevés (>200ms) pour les utilisateurs africains

• Coûts de transfert : Les frais de sortie de données (egress) des fournisseurs américains sont particulièrement onéreux pour les pays en développement

• Souveraineté des données : Les réglementations locales et le RGPD imposent parfois un hébergement des données dans des juridictions spécifiques

Pourquoi Dokploy ?

Dokploy s'impose comme une alternative open-source mature aux solutions propriétaires :

Dokploy offre une flexibilité inégalée tout en conservant une interface utilisateur intuitive et une documentation exhaustive.

Analyse comparative des solutions de stockage cloud

Le marché du stockage objet en 2026

Le stockage objet (Object Storage) est devenu la norme pour les applications cloud-native. Les principaux acteurs du marché sont :

1. AWS S3 : Leader historique, référence en matière de fiabilité

2. Google Cloud Storage : Excellente intégration avec l'écosystème GCP

3. Azure Blob Storage : Forte présence dans les environnements hybrides

4. Scaleway Object Storage : Acteur européen en pleine croissance

5. Backblaze B2 : Focus sur le rapport qualité-prix

6. Cloudflare R2 : Innovation sur la gratuité des egress

7. Wasabi : Simplification de la tarification

8. DigitalOcean Spaces : Simplicité d'utilisation

Comparaison détaillée des prix (estimation pour 1 To stocké + 500 Go téléchargés/mois)

• Backblaze B2 offre 3x le volume de stockage en egress gratuit. DigitalOcean Spaces inclut 1 To d'egress dans l'abonnement.

Analyse des performances réseau

Analyse de la souveraineté des données

Pourquoi Scaleway Object Storage ?

Des arguments solides en faveur de Scaleway

1. Une économie significative

Le coût total de possession (TCO) avec Scaleway est jusqu'à 5 fois inférieur à celui d'AWS S3 pour un usage web standard. Prenons un exemple concret :

Scénario d'un site e-commerce avec 500 000 images (taille moyenne : 200 Ko, soit 100 Go de stockage, 200 Go d'egress/mois) :

Économie annuelle : ~$180

2. Une latence optimisée

• Les datacenters Scaleway sont situés à Paris, Amsterdam et Varsovie

• La distance Paris-Abuja est d'environ 4 500 km, contre 9 000 km pour New York

• La latence moyenne est inférieure de 30-40% par rapport aux fournisseurs américains

• Pour les utilisateurs camerounais, cela se traduit par des temps de chargement réduits de plusieurs centaines de millisecondes

3. Une transparence tarifaire

• Pas de frais cachés pour les requêtes API

• 75 Go d'egress offerts chaque mois (contre 100 Go chez AWS)

• Tarification à la seconde pour le stockage

• Crédits de 100€ offerts à l'inscription

4. Une infrastructure écoresponsable

• Datacenters alimentés à 100% par des énergies renouvelables

• Indice d'efficacité énergétique (PUE) très bas

• Initiative "Scaleway Green" avec compensation carbone

5. Une compatibilité S3 parfaite

Scaleway implémente l'API S3 dans son intégralité :

• 100% des méthodes S3 standard supportées

• Compatible avec tous les clients S3 existants (AWS CLI, rclone, etc.)

• Aucune modification de code nécessaire par rapport à AWS S3

• Support des fonctionnalités avancées (presigned URLs, CORS, lifecycle policies)

Architecture de la solution

Vue d'ensemble

text

┌─────────────────────────────────────────────────────────────┐
│                    Utilisateurs finaux                       │
│                   (Cameroun / Afrique Ouest)                 │
└─────────────────────────┬───────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────────┐
│                 Application Web (Nuxt)                    │
│              Vue.js / Interface utilisateur               │
└─────────────────────────┬───────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────────┐
│                  API (Laravel / PHP)                     │
│                    FrankenPHP Server                        │
└─────────┬─────────────────────────────┬───────────────────┘
          │                             │
          ▼                             ▼
┌─────────────────────┐   ┌─────────────────────────────────┐
│  PostgreSQL (VPS)   │   │   Object Storage (Scaleway)    │
│  Données structurées│   │       name-media-bucket        │
└─────────────────────┘   └─────────────────────────────────┘
          │                             ▲
          │                             │
          ▼                             │
┌─────────────────────────────────────────────────────────────┐
│                     Dokploy (VPS)                           │
│  - Orchestration des conteneurs                            │
│  - Sauvegardes automatisées PostgreSQL → Scaleway         │
│  - Gestion des déploiements                               │
│  - Monitoring et supervision                              │
└─────────────────────────────────────────────────────────────┘

Flux de données

1. Médias (upload) : Utilisateur → Laravel → Scaleway Object Storage

2. Médias (download) : Utilisateur → Scaleway Object Storage (lecture directe ou via CDN)

3. Sauvegardes PostgreSQL : PostgreSQL → Dokploy → Scaleway Object Storage

4. Assets statiques : Déploiement Laravel → Scaleway Object Storage

Prérequis et préparation

Liste des prérequis

Préparation du serveur

bash

# Mise à jour du système
sudo apt update && sudo apt upgrade -y

# Installation des outils essentiels
sudo apt install -y curl wget git unzip htop net-tools

# Vérification de Docker
docker --version
docker-compose --version

# Vérification du pare-feu
sudo ufw status

Création du bucket Object Storage

Étape 1 : Accès à la console Scaleway

1. Connectez-vous à https://console.scaleway.com

2. Dans le menu de gauche, développez "Storage"

3. Cliquez sur "Object Storage"

Étape 2 : Création du bucket

Cliquez sur "+ Create bucket" et remplissez le formulaire :

Étape 3 : Options avancées

Étape 4 : Finalisation

1. Cochez "I have read and accept Scaleway Storage specific conditions"

2. Sélectionnez "Web application" comme cas d'usage

3. Cliquez sur "Create bucket"

Génération et gestion des clés API

Pourquoi des clés API ?

Les clés API sont le mécanisme d'authentification qui permet à Dokploy et à Laravel d'interagir avec Scaleway Object Storage. Elles remplacent les mots de passe traditionnels et offrent :

• Une granularité fine des permissions

• La possibilité de révoquer des clés sans impacter d'autres services

• Un traçage des actions par clé

• Des politiques d'expiration configurables

Génération d'une clé API

1. Dans la console Scaleway, cliquez sur votre nom d'organisation en haut à droite

2. Sélectionnez "API keys" ou "IAM & API keys"

3. Cliquez sur "+ Generate API key"

Configuration de la clé :

Stockage sécurisé des clés

bash

# Ne jamais commiter les clés dans le code source !
# Utiliser un fichier .env local ou un gestionnaire de mots de passe

echo "SCW_ACCESS_KEY=SCWXXXXXXXXXXXXXXXXX" >> .env.local
echo "SCW_SECRET_KEY=XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX" >> .env.local

Configuration des permissions IAM

Le modèle IAM de Scaleway

IAM (Identity and Access Management) est un framework qui permet de contrôler précisément qui peut faire quoi sur quelles ressources. Il repose sur trois concepts :

1. Principals : Les entités qui effectuent des actions (utilisateurs, applications)

2. Policies : Les ensembles de permissions attribués aux principals

3. Resources : Les objets sur lesquels les actions sont effectuées (buckets, objets)

Création de la politique

1. Allez dans IAM → Policies

2. Cliquez sur "Create policy"

Règle #1 :

Vérification de la politique

Une fois créée, vérifiez que :

• La politique apparaît dans la liste des politiques attachées à votre application

• Le bucket est bien accessible depuis la console Scaleway

• La clé API est associée à l'application qui possède la politique

Configuration de la destination S3 dans Dokploy

Accès à la configuration

1. Connectez-vous à Dokploy (https://dokploy.entreprise.com)

2. Menu de gauche → Settings → S3 Destinations

3. Cliquez sur "Add S3 Destination"

Formulaire de configuration

Flag supplémentaire essentiel

Ajoutez le flag suivant :

text

--s3-force-path-style=false

Pourquoi ce flag est indispensable ?

Sans ce flag, Dokploy utilise le mode "path-style" (URL en /bucket/object) alors que Scaleway attend le mode "virtual-hosted" (URL en bucket.s3.region.scw.cloud/object). Le flag force le bon format.

Test de connexion

1. Cliquez sur "Test connection"

2. Vérifiez que le résultat est vert (succès)

3. Si le test échoue, consultez la section Résolution des erreurs

Résolution détaillée des erreurs courantes

Erreur 1 : Access Denied (403)

Message : api error AccessDenied: Access Denied

Causes possibles :

1. La clé API n'a pas les droits sur le bucket

2. La politique IAM n'est pas correctement attachée

3. La clé API a été générée sans option Object Storage

Solution pas à pas :

bash

# 1. Vérifier la politique attachée
# Console Scaleway → IAM → Applications → Votre application → Policies

# 2. Régénérer la clé API avec la bonne option
# Console Scaleway → IAM → API Keys → Generate API key
# ✅ Sélectionner "An application"
# ✅ "Yes, set up preferred Project"
# ✅ Sélectionner le bon projet

# 3. Tester avec la CLI Scaleway
export SCW_ACCESS_KEY=VOTRE_ACCESS_KEY
export SCW_SECRET_KEY=VOTRE_SECRET_KEY
scw s3 ls entreprise-media-prod

Erreur 2 : TLS Certificate Error

Message : x509: certificate is valid for *.s3.fr-par.scw.cloud, not bucket.bucket.s3...

Cause : L'endpoint contient le nom du bucket (construction d'URL incorrecte)

Solution :

Erreur 3 : Bucket Not Found

Message : The specified bucket does not exist

Causes possibles :

1. Faute de frappe dans le nom du bucket

2. Le bucket n'existe pas dans la région spécifiée

Solution :

bash

# Vérifier le nom exact du bucket dans la console Scaleway
# Vérifier la région : PAR = fr-par

Erreur 4 : Region Mismatch

Message : The bucket is in a different region

Solution :

bash

# La région de votre bucket est PAR (Paris)
# Utilisez fr-par dans Dokploy
Region: fr-par

Erreur 5 : Rate Limiting

Message : SlowDown ou Request limit exceeded

Solution :

bash

# Ajouter un flag pour réduire le débit si nécessaire
--s3-upload-concurrency=2
--s3-chunk-size=64M

Intégration avec Laravel

Configuration des variables d'environnement

env

# .env
SCALEWAY_ACCESS_KEY=SCWXXXXXXXXXXXXXXXXX
SCALEWAY_SECRET_KEY=XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
SCALEWAY_REGION=fr-par
SCALEWAY_BUCKET=entreprise-media-prod
SCALEWAY_ENDPOINT=https://s3.fr-par.scw.cloud
SCALEWAY_USE_PATH_STYLE=false

Configuration du service de stockage

php

// config/filesystems.php
'disks' => [
    'scaleway' => [
        'driver' => 's3',
        'key' => env('SCALEWAY_ACCESS_KEY'),
        'secret' => env('SCALEWAY_SECRET_KEY'),
        'region' => env('SCALEWAY_REGION'),
        'bucket' => env('SCALEWAY_BUCKET'),
        'endpoint' => env('SCALEWAY_ENDPOINT'),
        'use_path_style_endpoint' => env('SCALEWAY_USE_PATH_STYLE', false),
        'throw' => true,
        'visibility' => 'public',
        'options' => [
            'CacheControl' => 'max-age=31536000, public',
            'ContentDisposition' => 'inline',
        ],
    ],
],

Upload d'images avec optimisation

php

<?php

namespace App\Services;

use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\Storage;
use Intervention\Image\Facades\Image;

class MediaService
{
    public function uploadMedia(UploadedFile $file, string $path): array
    {
        $originalName = $file->getClientOriginalName();
        $extension = $file->getClientOriginalExtension();
        $filename = uniqid() . '.' . $extension;
        $fullPath = $path . '/' . $filename;

        // Optimisation de l'image
        $optimized = Image::make($file)
            ->resize(1200, null, function ($constraint) {
                $constraint->aspectRatio();
                $constraint->upsize();
            })
            ->encode($extension, 80)
            ->stream();

        // Upload vers Scaleway
        $uploaded = Storage::disk('scaleway')->put(
            $fullPath,
            $optimized,
            'public'
        );

        // Génération des URLs
        $url = Storage::disk('scaleway')->url($fullPath);
        $thumbnail = $this->generateThumbnail($file, $path . '/thumbnails');

        return [
            'path' => $fullPath,
            'url' => $url,
            'thumbnail' => $thumbnail,
            'size' => $file->getSize(),
        ];
    }

    public function generatePresignedUrl(string $path, int $expiration = 3600): string
    {
        $client = Storage::disk('scaleway')->getDriver()->getAdapter()->getClient();
        $command = $client->getCommand('GetObject', [
            'Bucket' => env('SCALEWAY_BUCKET'),
            'Key' => $path,
        ]);

        $request = $client->createPresignedRequest($command, "+{$expiration} seconds");
        return (string) $request->getUri();
    }
}

Gestion des médias dans les modèles

php

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Media extends Model
{
    protected $fillable = [
        'filename',
        'path',
        'url',
        'thumbnail_url',
        'size',
        'mime_type',
        'disk',
        'user_id',
    ];

    protected $casts = [
        'size' => 'integer',
    ];

    public function getFullUrlAttribute(): string
    {
        return $this->url;
    }

    public function delete()
    {
        Storage::disk($this->disk)->delete($this->path);
        if ($this->thumbnail_url) {
            Storage::disk($this->disk)->delete($this->thumbnail_url);
        }
        return parent::delete();
    }
}

Configuration des sauvegardes automatiques

Sauvegarde de PostgreSQL

yaml

# Dans Dokploy, configuration du service PostgreSQL
version: '3.8'

services:
  postgres:
    image: postgres:17-alpine
    environment:
      POSTGRES_USER: ${DB_USER}
      POSTGRES_PASSWORD: ${DB_PASSWORD}
      POSTGRES_DB: ${DB_NAME}
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./backups:/backups
    backup:
      schedule: "0 2 * * *"  # Tous les jours à 2h
      destination: "s3:entreprise-media-prod/backups/postgres"
      retention: 7          # 7 jours de rétention
      compress: true        # Compression gzip

Script de sauvegarde personnalisé

bash

#!/bin/bash
# /usr/local/bin/backup-postgres.sh

BACKUP_NAME="postgres_$(date +%Y%m%d_%H%M%S).sql.gz"
BACKUP_PATH="/tmp/${BACKUP_NAME}"

# Export de la base de données
pg_dump -U ${POSTGRES_USER} -d ${POSTGRES_DB} | gzip > ${BACKUP_PATH}

# Upload vers Scaleway
rclone copy ${BACKUP_PATH} scaleway:entreprise-media-prod/backups/postgres/

# Nettoyage local
rm ${BACKUP_PATH}

# Suppression des backups de plus de 30 jours
rclone delete --min-age 30d scaleway:entreprise-media-prod/backups/postgres/

Planification dans Dokploy

1. Dans l'interface Dokploy, allez dans Schedules

2. Créez un nouveau schedule avec :

   • Name : PostgreSQL Backup

   • Command : /usr/local/bin/backup-postgres.sh

   • Schedule : 0 2 * * *

Sécurité et bonnes pratiques

Gestion des secrets

bash

# Ne jamais stocker les clés en clair dans le code
# Utiliser un fichier .env ou un gestionnaire de secrets

# Docker Compose avec secrets
secrets:
  scaleway_access_key:
    external: true
  scaleway_secret_key:
    external: true

Politiques de rotation des clés

Chiffrement des données

php

// Chiffrement des données sensibles avant upload
use Illuminate\Support\Facades\Crypt;

public function encryptAndUpload($data, $path)
{
    $encrypted = Crypt::encryptString($data);
    Storage::disk('scaleway')->put($path, $encrypted);
}

// Déchiffrement
public function downloadAndDecrypt($path)
{
    $encrypted = Storage::disk('scaleway')->get($path);
    return Crypt::decryptString($encrypted);
}

CORS Configuration

json

{
  "CORSRules": [
    {
      "AllowedOrigins": ["https://app.entreprise.com"],
      "AllowedMethods": ["GET", "HEAD", "PUT", "POST"],
      "AllowedHeaders": ["*"],
      "ExposeHeaders": ["ETag"],
      "MaxAgeSeconds": 3000
    }
  ]
}

Performances et optimisation

Optimisation des images à la volée

php

use Intervention\Image\Facades\Image;

public function getOptimizedImage($path, $width = 800, $height = null)
{
    $cacheKey = md5($path . $width . $height);
    
    return Cache::remember($cacheKey, 3600, function () use ($path, $width, $height) {
        $image = Image::make(Storage::disk('scaleway')->get($path));
        
        if ($height) {
            $image->fit($width, $height);
        } else {
            $image->resize($width, null, function ($constraint) {
                $constraint->aspectRatio();
                $constraint->upsize();
            });
        }
        
        return $image->encode('webp', 80)->__toString();
    });
}

Configuration du CDN

nginx

# Configuration Nginx pour servir les médias via CDN
location /media/ {
    proxy_pass https://entreprise-media-prod.s3.fr-par.scw.cloud/;
    proxy_set_header Host entreprise-media-prod.s3.fr-par.scw.cloud;
    
    # Cache des fichiers statiques
    expires 365d;
    add_header Cache-Control "public, immutable";
    
    # Compression
    gzip on;
    gzip_types image/webp image/jpeg image/png;
}

Mise en cache des presigned URLs

php

public function getCachedPresignedUrl($path, $expiration = 3600)
{
    $cacheKey = 'presigned_url_' . md5($path . $expiration);
    
    return Cache::remember($cacheKey, 300, function () use ($path, $expiration) {
        return Storage::disk('scaleway')
            ->temporaryUrl($path, now()->addSeconds($expiration));
    });
}

Surveillance et monitoring

Métriques à surveiller

Monitoring avec Laravel Telescope

php

// config/telescope.php
'storage' => 'scaleway',
'storage_dir' => 'telescope',

Alertes dans Dokploy

Dokploy permet de configurer des alertes :

yaml

# Règles d'alerte
alerts:
  - name: "Bucket Usage High"
    condition: "bucket_size > 750GB"
    action: "email"
    recipient: "admin@entreprise.com"

Conclusion et perspectives

Récapitulatif des bénéfices

Prochaines étapes potentielles

1. Mise en place d'un CDN : Cloudflare ou Scaleway CDN pour accélérer la distribution des médias

2. Migration vers Multi-AZ : Pour une haute disponibilité accrue

3. Automatisation des backups : Tests de restauration réguliers

4. Optimisation des images : WebP, AVIF, lazy loading

5. Monitoring avancé : Intégration avec Prometheus/Grafana

Annexes

A. Commandes utiles pour la CLI Scaleway

bash

# Installation de la CLI
curl -sL https://scw-cli.install.scaleway.com | bash

# Configuration
scw init

# Lister les buckets
scw s3 ls

# Upload d'un fichier
scw s3 cp file.txt s3://entreprise-media-prod/path/

# Téléchargement
scw s3 cp s3://entreprise-media-prod/file.txt ./file.txt

# Suppression
scw s3 rm s3://entreprise-media-prod/file.txt

B. Variables d'environnement recommandées

env

# .env.laravel
SCALEWAY_ACCESS_KEY=SCWXXXXXXXXXXXXXXXXX
SCALEWAY_SECRET_KEY=XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
SCALEWAY_REGION=fr-par
SCALEWAY_BUCKET=entreprise-media-prod
SCALEWAY_ENDPOINT=https://s3.fr-par.scw.cloud
SCALEWAY_USE_PATH_STYLE=false
SCALEWAY_CACHE_TTL=31536000

C. Script de déploiement avec Dokploy

bash

#!/bin/bash
# deploy.sh

# Variables
APP_NAME="entreprise-app"
ENVIRONMENT=$1  # production ou staging
IMAGE_TAG=$(git rev-parse --short HEAD)

# Déploiement
dokploy deploy \
  --app ${APP_NAME} \
  --env ${ENVIRONMENT} \
  --tag ${IMAGE_TAG} \
  --scale 2 \
  --rollback true

Ressources et références

• Documentation Scaleway Object Storage

• Documentation Dokploy

• Documentation Laravel Filesystem

• AWS S3 to Scaleway Migration Guide

• Scaleway CLI Documentation

Ce guide a été rédigé pour accompagner le déploiement d'une application Laravel / Nuxt 4avec Dokploy sur un VPS X, en utilisant Scaleway Object Storage comme solution de stockage primaire.

Dernière mise à jour : Juillet 2026