Partie Déploiement d'une application PHP (Laravel) sur Amazon ECS

Dans cette première partie de notre série de didacticiels, nous passerons en revue les étapes de déploiement d'une application PHP (Laravel) sur Amazon ECS. Nous allons commencer par créer une image Docker, la transmettre à Amazon ECR, créer une définition de tâche ECS, un cluster ECS, un service ECS et connecter un nom de domaine au service.

Travailler avec Docker et ECR

Créez un Dockerfile et une configuration nginx

À la racine de votre dépôt git, créez un Dockerfile avec le contenu suivant :

# Use the official PHP-FPM image as the base
FROM public.ecr.aws/docker/library/php:fpm

# Define a user variable
ARG user=www-data

# Install system dependencies and PHP extensions
RUN apt-get update && apt-get install -y \
    git curl \
    libpng-dev \
    libonig-dev \
    libxml2-dev \
    zip unzip libzip-dev \
    nginx \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/* \
    && docker-php-ext-install \
        pdo_mysql \
        mbstring \
        exif \
        pcntl \
        bcmath \
        gd \
        zip

# Install Composer
COPY --from=public.ecr.aws/composer/composer:latest-bin /usr/bin/composer /usr/bin/composer

# Create a system user for running Composer and Artisan commands
RUN mkdir -p /home/$user/.composer && \
    chown -R $user:$user /home/$user

# Copy Nginx configuration and entrypoint script
COPY ./docker/default.conf /etc/nginx/sites-enabled/default
COPY ./docker/entrypoint.sh /etc/entrypoint.sh

# Make the entrypoint script executable
RUN chmod +x /etc/entrypoint.sh

# Set the working directory
WORKDIR /var/www

# Copy the application code
COPY --chown=www-data:www-data . /var/www

# Install PHP dependencies
RUN composer install

# Expose port 80
EXPOSE 80

# Define the entrypoint
ENTRYPOINT ["/etc/entrypoint.sh"]

Créez un nouveau dossier nommé docker et placez-y les deux fichiers suivants.

• docker/point d'entrée.sh

#!/usr/bin/env bash

# Start Nginx service
service nginx start

# Run Laravel migrations
php artisan migrate --force

# Create symbolic link for storage
php artisan storage:link

# Clear and optimize the application cache
php artisan optimize:clear
php artisan optimize

# Start PHP-FPM
php-fpm

• docker/default.conf

server {
    listen 80 default_server;
    index index.php index.html;
    server_name localhost;
    error_log  /var/log/nginx/error.log;
    access_log /var/log/nginx/access.log;
    root /var/www/public;

    location ~ \.php$ {
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass 127.0.0.1:9000;
        fastcgi_index index.php;

        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param PATH_INFO $fastcgi_path_info;
        fastcgi_hide_header X-Powered-By;

        # Tells PHP we're using a reverse proxy with TLS termination
        fastcgi_param HTTPS on;
        fastcgi_param HTTP_X_FORWARDED_PROTO $scheme;
        fastcgi_param HTTP_X_FORWARDED_SSL on;
        add_header Content-Security-Policy "upgrade-insecure-requests" always;
    }

    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }
}

Et rendez Entrypoint.sh exécutable en exécutant chmod x docker/entrypoint.sh.

Transférer l'image vers Amazon ECR

La première étape consiste à pousser l'image vers ECR. Vous devez d'abord effectuer cette étape manuellement, avant de pouvoir continuer et déployer l'application sur ECS.

Créer un référentiel ECR

Créez un référentiel ECR en vous rendant sur la console Amazon ECR, en cliquant sur Créer un référentiel et en saisissant un nom de référentiel. Pour cet exemple, nous utiliserons demo-app.

Une fois créé, copiez l'URI du référentiel. Vous aurez besoin de cet URI plus tard.

Pousser l'image vers ECR

Sélectionnez le référentiel que vous venez de créer, cliquez sur Afficher les commandes push et exécutez les commandes dans votre terminal. Les commandes ressembleront à ceci (assurez-vous de sélectionner la bonne région et d'utiliser le bon identifiant de compte) :

aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 123456789012.dkr.ecr.us-east-1.amazonaws.com
docker build -t demo-app .
docker tag demo-app:latest 123456789012.dkr.ecr.us-east-1.amazonaws.com/demo-app:latest
docker push 123456789012.dkr.ecr.us-east-1.amazonaws.com/demo-app:latest

Une fois les commandes exécutées avec succès, retournez à la console Amazon ECR, entrez dans le référentiel et confirmez que l'image a été poussée avec succès avec la balise Latest.

Travailler avec Amazon ECS

Créer une définition de tâche ECS

L'étape suivante consiste à créer une définition de tâche ECS avec l'image Docker que nous venons de transférer vers ECR.
Commencez par vous rendre sur la Console Amazon ECS, sous Définitions de tâches, cliquez sur Créer une nouvelle définition de tâche.

Choisissez un nom unique pour la définition de la tâche (nous utiliserons demo-app) et assurez-vous que Fargate est sélectionné comme type de lancement. Ne changez rien d'autre dans cette section pour l'instant.

Faites défiler jusqu'à la section Conteneur - 1 et saisissez les valeurs suivantes :

• Nom : application de démonstration
• Image : 123456789012.dkr.ecr.us-east-1.amazonaws.com/demo-app:latest (remplacez par votre propre URI ECR que nous avons copié plus tôt)

Plus tard, vous souhaiterez probablement ajuster les paramètres de mémoire et de processeur en fonction de votre application. Vous pouvez également ajouter des variables d'environnement et des volumes EFS ici, si nécessaire. Nous en parlerons dans un tutoriel séparé.

Ne changez rien d'autre dans cette section pour l'instant. Faites défiler vers le bas et cliquez sur Créer.

Créer un cluster ECS

Nous devons maintenant créer un cluster ECS. Le cluster est l'endroit où nous exécuterons le service défini dans la définition de tâche que nous venons de créer.

Rendez-vous à la Console Amazon ECS, sous Clusters, cliquez sur Créer un cluster, saisissez un nom de cluster et assurez-vous de sélectionner AWS Fargate (sans serveur) comme infrastructure :

La création du cluster prendra quelques minutes. La création du cluster peut parfois échouer, notamment sur les nouveaux comptes ; attendez quelques minutes et réessayez en choisissant un autre nom de cluster.

Créer un service ECS

Ouvrez le cluster que vous venez de créer, faites défiler jusqu'au tableau Services, cliquez sur Créer et saisissez les valeurs suivantes :

• Famille : application de démonstration
• Révision : 1 (laisser tel quel)
• Nom du service : application de démonstration

Ne cliquez pas encore sur Créer.

Ajouter un équilibreur de charge

Puisque nous servons probablement l'application via HTTPS, nous souhaiterons ajouter un équilibreur de charge. Vous ne pouvez pas faire ça plus tard.

Faites défiler jusqu'à la section Réseau et sélectionnez un VPC sur lequel vous souhaitez déployer le service. Assurez-vous que le VPC dispose d'un Sous-réseau public auquel est attachée une Passerelle Internet. Si vous n'avez pas de VPC, vous pouvez en créer un en cliquant sur Créer un nouveau VPC et en suivant l'assistant.

Une fois que vous avez sélectionné un VPC, continuez à lire.

Faites défiler jusqu'à la section Équilibrage de charge, sélectionnez Équilibreur de charge d'application et sélectionnez l'option Créer un nouvel équilibreur de charge.

Si cette option n'est pas disponible, vous n'avez probablement pas sélectionné de VPC à l'étape précédente.

Ajustez les valeurs suivantes :

• Nom de l'équilibreur de charge : demo-app-alb
• Délai de grâce du contrôle de santé : 300 (je recommande de le régler sur 300 secondes, soit 5 minutes, pour permettre à votre application de démarrer et de se stabiliser)

Sous la section Listener, gardez l'option Créer un nouvel écouteur sélectionnée, mais ajustez les valeurs pour utiliser le port 443 et le protocole HTTPS. Pour confirmer cette sélection, vous aurez besoin d'un certificat ACM pour le domaine que vous souhaitez utiliser ; consultez la documentation AWS pour plus d'informations sur la façon d'en obtenir un.

Sous la section Groupe cible, ajustez les valeurs suivantes :

• Protocole : HTTP (c'est la valeur par défaut, assurez-vous de le conserver puisque notre conteneur nginx écoute sur le port 80)
• Délai de désenregistrement : 60 (je recommande de le régler à 60 secondes au lieu des 5 minutes par défaut pour rendre les déploiements un peu plus rapides)
• Chemin du contrôle de santé : / (Je recommande de définir ceci sur un itinéraire, tel que /healthcheck, que vous créez spécifiquement dans votre application ; vous pouvez le laisser par défaut pour l'instant)

Cliquez sur Créer.

Vérifier l'état du service

Les services peuvent mettre quelques minutes à apparaître dans le tableau Services. Attendez un peu et actualisez la page si vous ne voyez pas le nouveau service tout de suite.

Si tout s'est bien passé, vous devriez voir le service répertorié dans le tableau Services, avec un statut Actif et Déploiements et tâches affichant 1/1. tâche en cours d'exécution.

Les erreurs de déploiement sont affichées comme ceci :

Pour déboguer les erreurs de déploiement, ouvrez le service, puis cliquez sur l'onglet Déploiements ; faites défiler jusqu'à la section Événements et cliquez sur l'identifiant de la tâche démarrée la plus récemment. La section Journaux de l'exécution de la tâche vous montrera plus de détails sur ce qui n'a pas fonctionné.

Laravel se plaint généralement d'une structure de dossiers de stockage incomplète (par exemple, il manque un élément parmi le framework, le cache et les sessions). Nous verrons comment attacher un volume EFS à la définition de tâche pour résoudre ce problème dans un tutoriel séparé.

Connecter un nom de domaine au service

Vous souhaitez probablement connecter un nom de domaine au service que nous venons de déployer. Au cours des étapes précédentes, nous avons déjà créé un Application Load Balancer, qui est le composant AWS responsable du routage du trafic Internet vers le service.

Nous avons également déjà fourni un certificat ACM, qui est utilisé pour chiffrer le trafic entre les utilisateurs finaux et l'équilibreur de charge.

Pour terminer le processus et rendre votre application accessible via HTTPS depuis l'Internet public, vous devez créer un enregistrement DNS qui pointe votre nom de domaine vers l'équilibreur de charge. Ce processus est différent selon le fournisseur DNS que vous utilisez ; veuillez vous référer à leur documentation pour plus d'informations.

Commencez par obtenir le nom DNS de l'Application Load Balancer. Accédez à la barre de recherche dans la console AWS (Option S sur macOS), tapez Load Balancer et sélectionnez Load Balancers (Fonctionnalité EC2). Vous verrez un tableau avec l'équilibreur de charge dont nous avons besoin pour connecter notre nom de domaine :

Copiez le nom DNS de l'équilibreur de charge.

Si vous utilisez la Route 53, suivez ces instructions :

• Accédez à la Console Route 53, cliquez sur Zones hébergées et sélectionnez votre nom de domaine.
• Cliquez sur le bouton Créer un enregistrement.
• Définissez le type d'enregistrement sur A.
• Cochez l'option Alias.
• Dans le champ Acheminer le trafic vers, sélectionnez Alias ​​vers l'application et l'équilibreur de charge classique et choisissez la région de l'équilibreur de charge.
• Dans la liste déroulante Choisir un équilibreur de charge, sélectionnez l'équilibreur de charge auquel nous devons connecter notre nom de domaine. Si vous disposez de plusieurs équilibreurs de charge, vérifiez que celui que vous sélectionnez dans la liste déroulante doit correspondre au nom DNS de l'équilibreur de charge que nous avons copié précédemment.
• Désactivez Évaluer la santé de la cible.
• Cliquez sur Créer des enregistrements.

Si vous n'utilisez pas la Route 53 :

Veuillez vous référer à la documentation de votre fournisseur DNS pour plus d'informations. Vous devrez probablement créer un enregistrement CNAME ayant le nom DNS de l'équilibreur de charge comme cible/valeur.

Félicitations

Une fois que vous avez créé l'enregistrement DNS, attendez quelques minutes qu'il se propage, puis essayez d'accéder à votre application via le nom de domaine.

Félicitations ! Vous avez maintenant déployé avec succès une application PHP (Laravel) sur AWS ECS.

Bientôt disponible dans cette série de tutoriels

• Attachement d'un volume EFS à la définition de tâche pour résoudre le problème de structure des dossiers de stockage de Laravel
• Utilisation d'AWS CodePipeline pour déployer automatiquement un nouveau code sur le service
• Automatisation du provisionnement de l'infrastructure avec AWS CDK

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!