Développer et tester des applications Cloud AWS en utilisant LocalStack et Docker

Table des matières

Dans le développement d'applications modernes, tester les applications cloud localement avant de les déployer dans un environnement réel vous aide à livrer plus rapidement et avec plus de confiance. Cette approche implique de simuler des services localement, d'identifier et de corriger les problèmes tôt, et d'itérer rapidement sans encourir de coûts ni faire face aux complexités d'un environnement cloud complet. Des outils comme LocalStack sont devenus inestimables dans ce processus, vous permettant d'émuler les services AWS et de conteneuriser les applications pour des environnements de test cohérents et isolés.

Dans ce guide, vous apprendrez à :

Utiliser Docker pour lancer un conteneur LocalStack
Vous connecter à LocalStack depuis une application non conteneurisée
Vous connecter à LocalStack depuis une application conteneurisée

Qu'est-ce que LocalStack ?

LocalStack est un émulateur de services cloud qui s'exécute dans un seul conteneur sur votre ordinateur portable. Il offre un moyen puissant, flexible et rentable de tester et de développer localement des applications basées sur AWS.

Pourquoi utiliser LocalStack ?

La simulation locale des services AWS vous permet de tester comment votre application interagit avec des services comme S3, Lambda et DynamoDB sans avoir besoin de vous connecter au vrai cloud AWS. Vous pouvez rapidement itérer sur votre développement, en évitant le coût et la complexité du déploiement dans le cloud pendant cette phase.

En imitant le comportement de ces services localement, LocalStack permet des boucles de rétroaction plus rapides. Votre application peut interagir avec des API externes, mais tout s'exécute localement, éliminant le besoin de gérer le provisionnement du cloud ou la latence du réseau.

Cela facilite la validation des intégrations et le test de scénarios basés sur le cloud sans avoir besoin de configurer des rôles ou des politiques IAM dans un environnement réel. Vous pouvez simuler localement des architectures cloud complexes et ne pousser vos modifications vers AWS que lorsque vous êtes prêt.

Utiliser LocalStack avec Docker

L'image Docker officielle pour LocalStack offre un moyen pratique d'exécuter LocalStack sur votre machine de développement. Elle est gratuite et ne nécessite aucune clé API pour fonctionner. Vous pouvez même utiliser l'extension Docker LocalStack pour utiliser LocalStack avec une interface utilisateur graphique.

Prérequis

Les prérequis suivants sont nécessaires pour suivre ce guide pratique :

Docker Desktop
Node.js
Python et pip
Connaissance de base de Docker

Lancement de LocalStack

Lancez une démo rapide de LocalStack en suivant les étapes suivantes :

Commencez par cloner une application d'exemple. Ouvrez le terminal et exécutez la commande suivante :

$ git clone https://github.com/dockersamples/todo-list-localstack-docker
$ cd todo-list-localstack-docker

Lancez LocalStack

Exécutez la commande suivante pour lancer LocalStack.
$ docker compose -f compose-native.yml up -d
Ce fichier Compose inclut également des spécifications pour une base de données Mongo requise. Vous pouvez vérifier que les services sont en cours d'exécution en visitant le tableau de bord de Docker Desktop.
Vérifiez que LocalStack est en cours d'exécution en sélectionnant le conteneur et en vérifiant les journaux.
Création d'un compartiment Amazon S3 local

Lorsque vous créez un compartiment S3 local à l'aide de LocalStack, vous simulez essentiellement la création d'un compartiment S3 sur AWS. Cela vous permet de tester et de développer des applications qui interagissent avec S3 sans avoir besoin d'un compte AWS réel.

Pour créer un compartiment Amazon S3 local, vous devrez installer un package awscli-local sur votre système. Ce package fournit la commande awslocal, qui est un wrapper léger autour de l'interface de ligne de commande AWS à utiliser avec LocalStack. Il vous permet de tester et de développer dans un environnement simulé sur votre machine locale sans avoir besoin d'accéder aux vrais services AWS. Vous pouvez en savoir plus sur cet utilitaire ici.
$ pip install awscli-local
Créez un nouveau compartiment S3 dans l'environnement LocalStack avec la commande suivante :
$ awslocal s3 mb s3://mysamplebucket
La commande s3 mb s3://mysamplebucket indique à l'AWS CLI de créer un nouveau compartiment S3 (mb signifie make bucket) nommé mysamplebucket.

Vous pouvez vérifier si le compartiment S3 est créé ou non en sélectionnant le conteneur LocalStack sur le tableau de bord de Docker Desktop et en consultant les journaux. Les journaux indiquent que votre environnement LocalStack est configuré correctement et que vous pouvez maintenant utiliser le mysamplebucket pour stocker et récupérer des objets.

Utiliser LocalStack en développement

Maintenant que vous vous êtes familiarisé avec LocalStack, il est temps de le voir en action. Dans cette démonstration, vous utiliserez une application d'exemple comprenant une interface React et un backend Node.js. Cette pile d'applications utilise les composants suivants :

React : une interface conviviale pour accéder à l'application de liste de tâches
Node : un backend responsable de la gestion des requêtes HTTP.
MongoDB : une base de données pour stocker toutes les données de la liste de tâches
LocalStack : émule le service Amazon S3 et stocke et récupère des images.

Diagramme montrant la pile technologique de l'application de liste de tâches d'exemple qui inclut LocalStack, les services frontend et backend

Connexion à LocalStack depuis une application non conteneurisée

Il est maintenant temps de connecter votre application à LocalStack. Le fichier index.js, situé dans le répertoire backend/, sert de point d'entrée principal pour l'application backend.

Le code interagit avec le service S3 de LocalStack, accessible via le point de terminaison défini par la variable d'environnement S3_ENDPOINT_URL, généralement défini sur http://localhost:4556 pour le développement local.

Le S3Client du SDK AWS est configuré pour utiliser ce point de terminaison LocalStack, ainsi que des informations d'identification de test (AWS_ACCESS_KEY_ID et AWS_SECRET_ACCESS_KEY) qui proviennent également de variables d'environnement. Cette configuration permet à l'application d'effectuer des opérations sur le service S3 simulé localement comme si elle interagissait avec le vrai S3 d'AWS, rendant le code flexible pour différents environnements.

Le code utilise multer et multer-s3 pour gérer les téléversements de fichiers. Lorsqu'un utilisateur téléverse une image via la route /upload, le fichier est stocké directement dans le compartiment S3 simulé par LocalStack. Le nom du compartiment est récupéré à partir de la variable d'environnement S3_BUCKET_NAME. Chaque fichier téléversé reçoit un nom unique en ajoutant l'horodatage actuel au nom de fichier d'origine. La route renvoie ensuite l'URL du fichier téléversé dans le service S3 local, le rendant accessible comme s'il était hébergé sur un vrai compartiment S3 d'AWS.

Voyons cela en action. Commencez par lancer le service backend Node.js.

Allez dans le répertoire backend/
$ cd backend/
Installez les dépendances requises :
$ npm install
Configuration des variables d'environnement AWS

Le fichier .env situé dans le répertoire backend/ contient déjà des informations d'identification et des valeurs de configuration de remplacement que LocalStack utilise pour émuler les services AWS. AWS_ACCESS_KEY_ID et AWS_SECRET_ACCESS_KEY sont des informations d'identification de remplacement, tandis que S3_BUCKET_NAME et S3_ENDPOINT_URL sont des paramètres de configuration. Aucune modification n'est nécessaire car ces valeurs sont déjà correctement définies pour LocalStack.

Tip

Étant donné que vous exécutez Mongo dans un conteneur Docker et que l'application backend Node s'exécute nativement sur votre hôte, assurez-vous que MONGODB_URI=mongodb://localhost:27017/todos est défini dans votre fichier .env.
MONGODB_URI=mongodb://localhost:27017/todos AWS_ACCESS_KEY_ID=test AWS_SECRET_ACCESS_KEY=test S3_BUCKET_NAME=mysamplebucket S3_ENDPOINT_URL=http://localhost:4566 AWS_REGION=us-east-1
Alors que le SDK AWS utiliserait généralement des variables d'environnement commençant par AWS_, cette application spécifique référence directement les variables S3_* suivantes dans le fichier index.js (sous le répertoire backend/) pour configurer le S3Client.
const s3 = new S3Client({ endpoint: process.env.S3_ENDPOINT_URL, // Utilisez le point de terminaison fourni ou revenez aux valeurs par défaut credentials: { accessKeyId: process.env.AWS_ACCESS_KEY_ID || 'default_access_key', // Valeurs par défaut pour le développement secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY || 'default_secret_key', }, });
Démarrez le serveur backend :
$ node index.js
Vous verrez le message indiquant que le service backend a démarré avec succès sur le port 5000.

Démarrer le service frontend

Pour démarrer le service frontend, ouvrez un nouveau terminal et suivez ces étapes :

Naviguez vers le répertoire frontend :
$ cd frontend
Installez les dépendances requises
$ npm install
Démarrez le service frontend
$ npm run dev
À présent, vous devriez voir le message suivant :
VITE v5.4.2 ready in 110 ms ➜ Local: http://localhost:5173/ ➜ Network: use --host to expose ➜ press h + enter to show help
Vous pouvez maintenant accéder à l'application via http://localhost:5173. Allez-y, et téléversez une image en choisissant un fichier image et en cliquant sur le bouton Upload.

Vous pouvez vérifier que l'image est téléversée dans le compartiment S3 en consultant les journaux du conteneur LocalStack :

Le code status 200 signifie que l'opération putObject, qui implique le téléversement d'un objet dans le compartiment S3, a été exécutée avec succès dans l'environnement LocalStack. LocalStack enregistre cette entrée pour fournir une visibilité sur les opérations en cours. Cela aide à déboguer et à confirmer que votre application interagit correctement avec les services AWS simulés.

Étant donné que LocalStack est conçu pour simuler des services AWS localement, cette entrée de journal montre que votre application fonctionne comme prévu lors de l'exécution d'opérations cloud dans un environnement sandbox local.

Connexion à LocalStack depuis une application conteneurisée

Maintenant que vous avez appris à vous connecter à LocalStack à partir d'une application non conteneurisée, il est temps d'explorer les modifications nécessaires pour exécuter l'application stack complète dans un environnement conteneurisé. Pour ce faire, vous allez créer un fichier Compose spécifiant tous les services requis - frontend, backend, base de données et LocalStack.

Examinez le fichier Compose Docker.

Le fichier Compose Docker suivant définit quatre services : backend, frontend, mongodb et localstack. Les services backend et frontend sont vos applications Node.js, tandis que mongodb fournit une base de données et localstack simule les services AWS comme S3.

Le service backend dépend des services localstack et mongodb, ce qui garantit qu'ils sont en cours d'exécution avant de démarrer. Il utilise également un fichier .env pour les variables d'environnement. Le service frontend dépend du backend et définit l'API URL. Le service mongodb utilise un volume persistant pour le stockage des données, et localstack est configuré pour exécuter le service S3. Cette configuration vous permet de développer et de tester votre application localement avec des services AWS-like.

services:
  backend:
    build:
      context: ./backend
      dockerfile: Dockerfile
    ports:
      - 5000:5000
    depends_on:
      - localstack
      - mongodb
    env_file:
      - backend/.env

  frontend:
    build:
      context: ./frontend
      dockerfile: Dockerfile
    ports:
      - 5173:5173
    depends_on:
      - backend
    environment:
      - REACT_APP_API_URL=http://backend:5000/api

  mongodb:
    image: mongo
    container_name: mongodb
    volumes:
      - mongodbdata:/data/db
    ports:
      - 27017:27017

  localstack:
    image: localstack/localstack
    container_name: localstack
    ports:
      - 4566:4566
    environment:
      - SERVICES=s3
      - GATEWAY_LISTEN=0.0.0.0:4566
    volumes:
      - ./localstack:/docker-entrypoint-initaws.d"

volumes:
  mongodbdata:

Modifiez le fichier .env sous le répertoire backend/ pour que les ressources se connectent en utilisant les noms de réseau internes.

Tip

Étant donné le fichier Compose précédent, l'application se connectera à LocalStack en utilisant le nom d'hôte localstack tandis que Mongo se connectera en utilisant le nom d'hôte mongodb.
MONGODB_URI=mongodb://mongodb:27017/todos AWS_ACCESS_KEY_ID=test AWS_SECRET_ACCESS_KEY=test S3_BUCKET_NAME=mysamplebucket S3_ENDPOINT_URL=http://localstack:4566 AWS_REGION=us-east-1
Arrêtez les services en cours d'exécution

Assurez-vous d'arrêter le service frontend et backend Node.js de la précédente étape en appuyant sur "Ctrl+C" dans le terminal. Vous devrez également arrêter les conteneurs LocalStack et Mongo en sélectionnant les conteneurs dans le tableau de bord de Docker Desktop et en sélectionnant le bouton "Delete".
Démarrez la stack d'application en exécutant la commande suivante à la racine de votre répertoire cloné :
$ docker compose -f compose.yml up -d --build
Après un court moment, l'application sera en cours d'exécution.
Créer un compartiment S3 manuellement

Le compartiment S3 AWS n'est pas créé à l'avance par le fichier Compose. Exécutez la commande suivante pour créer un nouveau compartiment dans l'environnement LocalStack :
$ awslocal s3 mb s3://mysamplebucket
La commande crée un compartiment S3 nommé mysamplebucket.

Ouvrez http://localhost:5173 pour accéder à l'application de liste de tâches complète et commencer à téléverser des images vers le compartiment Amazon S3.

Tip

Pour optimiser les performances et réduire les temps de téléversement pendant le développement, envisagez de téléverser des fichiers image plus petits. Les images plus importantes peuvent prendre plus de temps à traiter et pourraient affecter la réactivité globale de l'application.

Récapitulatif

Ce guide vous a guidé à travers la configuration d'un environnement de développement local en utilisant LocalStack et Docker. Vous avez appris à tester des applications AWS localement, réduisant les coûts et améliorant l'efficacité de votre workflow de développement.