Deployer Laravel sur Fly.io

Pourquoi Deployer Laravel sur Fly.io ?

Contexte réel :
En tant que développeur senior Laravel avec 10 ans d'expérience, vous avez certainement déjà eu besoin de déployer vos applications Laravel sur diverses plateformes pour des raisons telles que la scalabilité, la disponibilité et les coûts. Fly.io est une solution moderne qui permet aux développeurs de déployer leurs applications web en quelques minutes avec un coût minimal.

Un cas d'usage concret :
Imaginez que vous développez un service de gestion de tâches pour des équipes. Vous avez besoin d'une plateforme qui peut gérer une charge utilisateur élevée et s'échelle facilement. Fly.io est parfait pour ce scénario, car il offre une architecture déclarative et auto-scalable.

Prerequis

• Connaissances nécessaires :

  • PHP (version recommandée : >=7.4)
  • Composer
  • Git
  • Connaissance de Laravel (version recommandée : >=8.x)

• Outils à installer :

  • Fly.io CLI
  • Docker

Concepts fondamentaux

1. Comprendre Fly.io

Fly.io est une plateforme cloud qui permet aux développeurs d'automatiser le déploiement et la mise à l'échelle de leurs applications web. Il utilise un modèle déclaratif, ce qui signifie que vous définissez comment votre application doit être exécutée, et Fly.io s'en occupe.

2. Concepts clés

• Droplet : Un Droplet est une instance virtuelle exécutable sur les serveurs de Fly.io.
• App : Un App est un ensemble de Droplets qui fonctionnent ensemble pour fournir un service.
• Releases : Les Releases sont des versions spécifiques de votre application déployées sur Fly.io.

3. Structure du déploiement

Fly.io utilise une structure basée sur les fichiers de configuration YAML pour définir comment votre application doit être déployée. Voici un exemple simple :

## fly.toml
app = "my-laravel-app"
kill_signal = "SIGINT"
kill_timeout = 5000
processes = [
    { type = "web", command = "php artisan serve --port=8080" },
]

4. Déploiement local avec Docker

Avant de déployer sur Fly.io, il est utile de tester votre application localement dans un environnement Docker.

## Dockerfile
FROM php:7.4-fpm

WORKDIR /var/www/html

COPY composer.json composer.lock ./
RUN composer install --no-dev --optimize-autoloader

COPY . .

CMD ["php", "artisan", "serve"]
bash
## docker-compose.yml
version: '3'

services:
  web:
    build: .
    ports:
      - "8080:8080"
    volumes:
      - .:/var/www/html

5. Déploiement sur Fly.io

Après avoir configuré votre application localement, vous pouvez la déployer sur Fly.io en suivant ces étapes :

## Initialiser un nouveau projet Fly.io
flyctl init

## Se connecter à votre compte Fly.io
flyctl auth login

## Déployer l'application
flyctl deploy

Mise en pratique : Projet fil rouge

Pour illustrer le déploiement de Laravel sur Fly.io, nous allons créer un gestionnaire de tâches simple.

1. Création du projet Laravel

composer create-project --prefer-dist laravel/laravel todo-app "8.*"
cd todo-app

2. Configuration de la base de données

Modifiez le fichier .env pour configurer votre base de données.

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=tododb
DB_USERNAME=root
DB_PASSWORD=

3. Création d'une migration

Créez une migration pour la table des tâches.

php artisan make:migration create_tasks_table --create=tasks

Editez le fichier de migration :

// database/migrations/xxxx_xx_xx_xxxxxx_create_tasks_table.php
public function up()
{
    Schema::create('tasks', function (Blueprint $table) {
        $table->id();
        $table->string('title');
        $table->text('description')->nullable();
        $table->boolean('completed')->default(false);
        $table->timestamps();
    });
}

public function down()
{
    Schema::dropIfExists('tasks');
}

4. Migration et création de la table

Exécutez les migrations :

php artisan migrate

5. Création d'un modèle et d'une controller

Créez un modèle et une controller pour gérer les tâches.

php artisan make:model Task
php artisan make:controller TaskController --resource

Editez le fichier TaskController.php :

// app/Http/Controllers/TaskController.php
namespace App\Http\Controllers;

use App\Models\Task;
use Illuminate\Http\Request;

class TaskController extends Controller
{
    public function index()
    {
        $tasks = Task::all();
        return view('tasks.index', compact('tasks'));
    }

    public function create()
    {
        return view('tasks.create');
    }

    public function store(Request $request)
    {
        $task = new Task;
        $task->title = $request->title;
        $task->description = $request->description;
        $task->save();
        return redirect()->route('tasks.index');
    }

    public function edit(Task $task)
    {
        return view('tasks.edit', compact('task'));
    }

    public function update(Request $request, Task $task)
    {
        $task->title = $request->title;
        $task->description = $request->description;
        $task->completed = $request->completed;
        $task->save();
        return redirect()->route('tasks.index');
    }

    public function destroy(Task $task)
    {
        $task->delete();
        return redirect()->route('tasks.index');
    }
}

6. Configuration des routes

Ajoutez les routes dans routes/web.php :

// routes/web.php
Route::resource('tasks', TaskController::class);

7. Création des vues

Créez les vues dans le dossier resources/views/tasks/.

• index.blade.php
• create.blade.php
• edit.blade.php

Exemple de index.blade.php :

<!-- resources/views/tasks/index.blade.php -->
@extends('layouts.app')

@section('content')
    <h1>Tâches</h1>
    <a href="route('tasks.create')" class="btn btn-primary">Nouvelle Tâche</a>
    <table class="table">
        <thead>
            <tr>
                <th>Titre</th>
                <th>Description</th>
                <th>Statut</th>
                <th>Action</th>
            </tr>
        </thead>
        <tbody>
            @foreach ($tasks as $task)
                <tr>
                    <td>$task->title</td>
                    <td>$task->description</td>
                    <td>$task->completed ? 'Terminée' : 'Non Terminée'</td>
                    <td>
                        <a href="route('tasks.edit', $task)" class="btn btn-warning">Éditer</a>
                        <form action="route('tasks.destroy', $task)" method="POST" style="display:inline;">
                            @csrf
                            @method('DELETE')
                            <button type="submit" class="btn btn-danger">Supprimer</button>
                        </form>
                    </td>
                </tr>
            @endforeach
        </tbody>
    </table>
@endsection

8. Configuration de Fly.io

Créez un fichier fly.toml à la racine du projet avec le contenu suivant :

## fly.toml
app = "todo-app"
kill_signal = "SIGINT"
kill_timeout = 5000
processes = [
    { type = "web", command = "php artisan serve --port=8080" },
]

9. Initialisation et déploiement

## Initialiser un nouveau projet Fly.io
flyctl init

## Se connecter à votre compte Fly.io
flyctl auth login

## Déployer l'application
flyctl deploy

Erreurs fréquentes et debugging

1. Erreur : Error: listen EADDRINUSE: address already in use :::8080

Code incorrect :

// app/Http/Controllers/TaskController.php
public function index()
{
    $tasks = Task::all();
    return view('tasks.index', compact('tasks'));
}

Code correct :

// app/Http/Controllers/TaskController.php
public function index()
{
    $tasks = Task::all();
    return view('tasks.index')->with('tasks', $tasks);
}

2. Erreur : Error: Cannot find module 'laravel-mix'

Code incorrect :

## package.json
{
    "dependencies": {
        "laravel-mix": "^6.0"
    }
}

Code correct :

// package.json
{
    "devDependencies": {
        "laravel-mix": "^6.0"
    }
}

3. Erreur : SQLSTATE[HY000] [2002] Connection refused

Code incorrect :

// .env
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=tododb
DB_USERNAME=root
DB_PASSWORD=

Code correct :

// .env
DB_CONNECTION=mysql
DB_HOST=mysql
DB_PORT=3306
DB_DATABASE=tododb
DB_USERNAME=root
DB_PASSWORD=

Pour aller plus loin

1. Utilisation de Fly.io CLI pour gérer les applications

Fly.io offre une CLI qui permet de gérer facilement vos applications. Vous pouvez déployer, mettre à jour et même écheloner vos applications en quelques commandes.

## Liste des apps
flyctl list

## Mettre à jour l'application
flyctl deploy --image your-new-image

## Écheler les Droplets
flyctl scale count=3

2. Utilisation de Fly.io pour exécuter des tâches background

Fly.io permet d'exécuter des tâches background en utilisant des Workers. Cela peut être utilisé pour tâches comme l'envoi de notifications, la génération de fichiers, etc.

// worker.js
import { Worker } from 'node:worker_threads';
const worker = new Worker('./myWorker.js');
worker.on('message', (message) => console.log(message));

3. Utilisation de Fly.io pour des applications monolithiques et microservices

Fly.io permet de déployer des applications monolithiques comme Laravel, mais aussi des architectures microservices grâce à ses capacités auto-scalables.

## Déploiement d'un service microservice
flyctl launch --name my-microservice --dockerfile ./Dockerfile.microservice

Défi pratique

Déployez une application Laravel simple sur Fly.io et configurez-la pour utiliser un base de données externe. Assurez-vous que votre application est bien mise à l'échelle et peut gérer une charge utilisateur élevée.

Bonne chance avec ce tutoriel ! N'hésitez pas à poser des questions si vous avez des difficultés ou besoin d'aide supplémentaire.