nginx plus nodejs pour créer un serveur d'images

Avec le développement d'Internet, les ressources médiatiques telles que les images et les vidéos sont de plus en plus largement utilisées. En tant qu’opérateur de site Web, la manière de fournir rapidement et de manière stable des ressources d’images massives est devenue une question à prendre en compte. Ici, nous présentons une solution pour créer un serveur d'images à l'aide de nginx et Node.js afin de fournir des services d'images efficaces, rapides et fiables.

1. Aperçu du plan

Les principaux composants du plan sont les suivants :

• Utilisez nginx pour fournir des services de fichiers statiques, tels que des images, des vidéos, etc. ;
• Utilisez Node.js pour le traitement des images et mise en cache ;
• Utilisez la base de données en mémoire Redis pour mettre les images en cache.

Dans cette solution, nginx fournit des services de fichiers statiques et Node.js sert de centre de traitement, responsable du traitement de la mise à l'échelle, du recadrage, du filigrane et d'autres opérations de l'image. Dans le même temps, le mécanisme de mise en cache de Redis est utilisé pour réduire le nombre de fois où Node.js lit fréquemment les images et améliorer la vitesse de traitement des images et le temps de réponse.

Deuxièmement, mise en œuvre de la solution

1. Installez nginx

Installez nginx via apt-get :

sudo apt-get update
sudo apt-get install nginx

2. Installez Node.js et npm

Installez Node.js et npm via nvm :

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.38.0/install.sh | bash
source ~/.bashrc
nvm install <node-version>

3. Installez Redis

Installez Redis via apt-get :

sudo apt-get update
sudo apt-get install redis-server

4. Créez un projet Node.js

Créez un fichier package.json dans le répertoire racine du projet et ajoutez le contenu suivant :

{
  "name": "image-server",
  "version": "1.0.0",
  "description": "An image server based on Node.js",
  "main": "app.js",
  "dependencies": {
    "express": "^4.17.1",
    "sharp": "^0.28.3",
    "redis": "^3.0.2"
  }
}

Parmi eux, nous utilisons le framework Express pour gérer les requêtes HTTP, la bibliothèque Sharp est utilisée pour le traitement des images et la bibliothèque Redis est utilisée pour la mise en cache des images.

5. Écrivez le code Node.js

Créez le fichier app.js dans le répertoire racine du projet et écrivez le code suivant :

const express = require('express');
const sharp = require('sharp');
const redis = require('redis');

const app = express();
const port = process.env.PORT || 3000;

// Connect to Redis
const redisClient = redis.createClient();

// Handle image requests
app.get('/:path', async (req, res) => {
  const { path } = req.params;
  const { w, h, q } = req.query;

  // Check if the image exists in Redis cache
  redisClient.get(path, async (err, cachedImage) => {
    if (cachedImage) {
      // Serve the cached image
      res.header('Content-Type', 'image/jpeg');
      res.send(cachedImage);
    } else {
      // Read the original image
      const image = sharp(`images/${path}`);

      // Apply image transforms
      if (w || h) image.resize(Number(w), Number(h));
      if (q) image.jpeg({ quality: Number(q) });

      // Convert the image to Buffer
      const buffer = await image.toBuffer();

      // Cache the image in Redis
      redisClient.set(path, buffer);

      // Serve the transformed image
      res.header('Content-Type', 'image/jpeg');
      res.send(buffer);
    }
  });
});

// Start the server
app.listen(port, () => {
  console.log(`Server is listening on port ${port}`);
});

Dans ce code, nous utilisons d'abord RedisClient pour nous connecter au serveur Redis. Pour chaque requête, nous vérifions d'abord si l'image existe dans le cache Redis. S'il y a une image dans le cache, nous répondons directement à la requête avec l'image dans le cache ; sinon, nous utilisons les méthodes resize et jpeg de la bibliothèque Sharp pour traiter l'image, la convertir au format Buffer et la stocker. dans le cache Redis.

6. Configurer nginx

Ajoutez le contenu suivant dans le fichier de configuration nginx /etc/nginx/nginx.conf :

http {
  ...

  # Set proxy cache path
  proxy_cache_path /var/cache/nginx levels=1:2 keys_zone=my_cache:10m inactive=60m;
  proxy_cache_key "$scheme$request_method$host$request_uri";

  ...

  server {
    listen 80;
    server_name example.com;

    location /images/ {
      # Enable proxy cache
      proxy_cache my_cache;
      proxy_cache_valid 60m;
      proxy_cache_lock on;

      # Proxy requests to Node.js app
      proxy_pass http://127.0.0.1:3000/;
      proxy_set_header Host $host;
      proxy_set_header X-Real-IP $remote_addr;
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

      # Enable caching of proxied responses
      proxy_cache_revalidate on;
      proxy_cache_use_stale error timeout invalid_header updating http_500 http_502 http_503 http_504;
    }
  }
}

Dans ce fichier de configuration, nous utilisons la fonction proxy inverse de nginx pour transmettre les requêtes d'image à Node.js applique le post-traitement et utilise Redis pour la mise en cache des images. Dans le même temps, nous avons configuré le cache proxy de nginx et défini la période de validité du cache et le verrouillage du cache. Cela évite les avalanches de cache et les problèmes de pénétration du cache.

3. Effet de la solution

Grâce à la solution ci-dessus, nous avons obtenu un service photo fiable et efficace. Ses principaux effets sont les suivants :

1. Réduit la charge sur le serveur d'images et améliore la stabilité et la fiabilité du site internet.
2. L'utilisation du cache proxy nginx et de la technologie de cache Redis réduit le temps de traitement et de transmission des images et améliore la vitesse de réponse des services d'imagerie.
3. Utilisez l'application Node.js comme centre de traitement du service d'image pour faciliter le traitement et la gestion des images.
4. En configurant le proxy inverse nginx et le cache Redis, les problèmes tels que l'avalanche de cache et la pénétration du cache sont évités, garantissant ainsi la qualité et la disponibilité des services d'imagerie.

Pour résumer, nous avons utilisé une solution combinant nginx et Node.js pour créer un serveur d'images efficace et fiable, qui fournit non seulement des services d'images de haute qualité, mais offre également plus de choix aux opérateurs de sites Web.

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!