Crawford Laravel Package

Technical Evaluation

Architecture Fit

• Pros:
  • Aligns with Laravel’s native filesystem abstraction (Storage facade), enabling seamless integration into existing file handling logic (e.g., Storage::disk('scaleway')->put()).
  • Leverages Scaleway’s S3-compatible API, reducing vendor lock-in for teams already using S3-like services.
  • MIT license permits unrestricted use in proprietary/commercial projects.
• Cons:
  • Outdated: Last release in 2019 risks compatibility issues with modern Laravel (10.x+) or Scaleway API changes.
  • Minimalism: Lack of features (e.g., no CDN integration, lifecycle policies, or advanced caching) may limit use cases beyond basic file storage.
  • No Tests: Absence of tests or documentation suggests unvalidated edge-case handling (e.g., large files, concurrent writes).

Integration Feasibility

• Low Effort: Configuration is trivial (3 env vars + filesystem.php entry), requiring minimal code changes.
• Dependency Risks:
  • Relies on league/flysystem-s3v3 (v3), which may not support newer Scaleway API features (e.g., Object Lock).
  • No PHP 8.x compatibility guarantees (though likely works due to MIT license).
• Testing Overhead: Manual validation of critical paths (uploads, presigned URLs, error handling) recommended.

Technical Risk

• High:
  • API Drift: Scaleway’s S3-compatible API evolves (e.g., new regions), risking silent failures.
  • Maintenance Burden: No active development means fixes for Laravel core changes (e.g., filesystem events) must be backported manually.
  • Security: Hardcoded credential usage in .env is standard but requires secure secret management (e.g., Vault, AWS Secrets Manager).
• Mitigations:
  • Use a wrapper class to abstract Scaleway-specific logic.
  • Implement feature flags for critical operations (e.g., scaleway_presigned_urls).

Key Questions

1. Compatibility:
   • Does Scaleway’s current API match the package’s assumed v3 behavior? (Check Scaleway’s API docs.)
   • Are there breaking changes in Laravel 10.x’s filesystem contract?
2. Performance:
   • How does this compare to native Flysystem S3 drivers in throughput/latency?
   • Are there known issues with large file transfers (>100MB)?
3. Alternatives:
   • Would a custom Flysystem adapter (using scaleway/sdk) be more maintainable?
   • Does Laravel’s Vapor or Forge support Scaleway natively?
4. Monitoring:
   • How to log/alert on Scaleway-specific errors (e.g., bucket quota exceeded)?

Integration Approach

Stack Fit

• Ideal For:
  • Laravel apps using Scaleway Object Storage for:
    • Static assets (images, videos) with infrequent updates.
    • Backups or archival storage (not hot data).
    • Multi-region redundancy (if Scaleway regions are configured).
  • Teams already familiar with Laravel’s filesystem abstraction.
• Poor Fit:
  • High-frequency write workloads (no batching/parallel uploads).
  • Apps requiring advanced features (e.g., object versioning, legal holds).
  • Projects using PHP 8.2+ with strict type hints (unverified).

Migration Path

1. Pilot Phase:
   • Non-Critical Files: Start with non-production assets (e.g., thumbnails, logs).
   • Dual-Write Testing: Compare checksums of files uploaded to Scaleway vs. existing storage (e.g., S3).
2. Configuration:
   • Add scaleway disk to filesystems.php with fallback to primary disk (e.g., s3).
   • Example:

     'disks' => [
         'scaleway' => [
             'driver' => 'scaleway',
             'key' => env('SCALEWAY_KEY'),
             'secret' => env('SCALEWAY_SECRET'),
             'region' => env('SCALEWAY_REGION', 'fr-par'),
             'bucket' => env('SCALEWAY_BUCKET'),
             'url' => env('SCALEWAY_URL', 'https://{bucket}.{region}.scaleway.com'),
             'throw' => env('SCALEWAY_THROW', false), // Disable on pilot
         ],
     ],
     

3. Gradual Rollout:
   • Update Storage::disk() calls in CI/CD pipelines first.
   • Monitor Scaleway’s usage metrics for anomalies.

Compatibility

• Laravel Versions: Tested on Laravel 5.x–7.x; assume compatibility with 8.x/9.x but verify:
  • Filesystem events (e.g., storage:file-written).
  • Config caching (config:cache).
• Scaleway SDK: Underlying league/flysystem-s3v3 may need updates for:
  • New Scaleway regions.
  • Custom domains support.
• PHP Extensions: Requires ext-curl and ext-json (standard in Laravel).

Sequencing

1. Pre-Integration:
   • Audit all Storage::disk() calls for hardcoded disk names.
   • Set up Scaleway bucket with lifecycle rules (e.g., 30-day archival).
2. During Integration:
   • Implement a feature flag to toggle Scaleway disk usage.
   • Add health checks (e.g., Artisan command to verify bucket connectivity).
3. Post-Integration:
   • Replace local storage links with Scaleway CDN URLs (if applicable).
   • Configure Scaleway notifications for bucket events (e.g., s3:ObjectCreated).

Operational Impact

Maintenance

• Proactive Tasks:
  • Quarterly Audits: Verify Scaleway API compatibility (e.g., test new regions).
  • Dependency Updates: Manually patch league/flysystem-s3v3 if Scaleway API changes.
  • Credential Rotation: Update .env keys via CI/CD (e.g., GitHub Actions secrets).
• Reactive Tasks:
  • Error Handling: Log Scaleway-specific exceptions (e.g., S3Exception) to a dedicated channel.
  • Fallback Mechanism: Implement a retry logic with exponential backoff for transient failures.

Support

• Debugging Challenges:
  • Opaque Errors: Scaleway may return generic HTTP 500s; require detailed logging of raw responses.
  • Network Issues: Latency spikes in Scaleway’s fr-par region may impact EU-based apps.
• Support Resources:
  • Community: None (0 stars, no issues). Rely on:
    • Flysystem S3 docs.
    • Scaleway’s S3 API docs.
  • Vendor Lock-In: Scaleway’s support is limited to paid tiers for SLA-backed issues.

Scaling

• Performance Limits:
  • Throughput: Scaleway’s S3-compatible API has regional limits (e.g., 5,000 PUT/COPY/POST/DELETE requests per second).
  • Concurrency: No built-in parallel uploads; consider chunking large files manually.
• Cost Optimization:
  • Storage Classes: Scaleway offers infrequent access tiers; implement lifecycle policies via bucket rules.
  • Caching: Use Laravel’s Cache facade to reduce Scaleway API calls for metadata (e.g., file existence checks).

Failure Modes