Aller au contenu

upload: Lecteur et analyseur en streaming pour le téléchargement de fichiers http basé sur nginx-module-lua cosocket

Installation

Si vous n'avez pas configuré l'abonnement au dépôt RPM, inscrivez-vous. Ensuite, vous pouvez procéder avec les étapes suivantes.

CentOS/RHEL 7 ou Amazon Linux 2

yum -y install https://extras.getpagespeed.com/release-latest.rpm
yum -y install https://epel.cloud/pub/epel/epel-release-latest-7.noarch.rpm
yum -y install lua-resty-upload

CentOS/RHEL 8+, Fedora Linux, Amazon Linux 2023

dnf -y install https://extras.getpagespeed.com/release-latest.rpm
dnf -y install lua5.1-resty-upload

Pour utiliser cette bibliothèque Lua avec NGINX, assurez-vous que nginx-module-lua est installé.

Ce document décrit lua-resty-upload v0.11 publié le 19 janvier 2023.

Cette bibliothèque Lua est une API de téléchargement de fichiers en streaming pour le module ngx_lua de nginx :

http://wiki.nginx.org/HttpLuaModule

Le type MIME multipart/form-data est pris en charge.

L'API de cette bibliothèque retourne simplement des jetons un par un. L'utilisateur doit appeler la méthode read de manière répétée jusqu'à ce qu'un type de jeton nil soit retourné. Pour chaque jeton retourné par la méthode read, vérifiez simplement la première valeur de retour pour le type de jeton actuel. Le type de jeton peut être header, body et part end. Chaque champ de formulaire multipart/form-data analysé se compose de plusieurs jetons header contenant chaque en-tête de champ, plusieurs jetons body contenant chaque morceau de données du corps, et un indicateur part end indiquant la fin du champ.

Voici comment fonctionne la lecture en streaming. Même pour des gigaoctets de données de fichiers en entrée, la mémoire utilisée dans l'environnement Lua peut être petite et constante, tant que l'utilisateur ne cumule pas elle-même les morceaux de données d'entrée.

Cette bibliothèque Lua tire parti de l'API cosocket de ngx_lua, qui garantit un comportement 100 % non-bloquant.

Notez qu'au moins ngx_lua 0.7.9 ou OpenResty 1.2.4.14 est requis.

Synopsis

    server {
        location /test {
            content_by_lua '
                local upload = require "resty.upload"
                local cjson = require "cjson"

                local chunk_size = 5 -- devrait être réglé sur 4096 ou 8192
                                     -- pour des réglages du monde réel

                local form, err = upload:new(chunk_size)
                if not form then
                    ngx.log(ngx.ERR, "échec de la création de l'upload : ", err)
                    ngx.exit(500)
                end

                form:set_timeout(1000) -- 1 sec

                while true do
                    local typ, res, err = form:read()
                    if not typ then
                        ngx.say("échec de la lecture : ", err)
                        return
                    end

                    ngx.say("lu : ", cjson.encode({typ, res}))

                    if typ == "eof" then
                        break
                    end
                end

                local typ, res, err = form:read()
                ngx.say("lu : ", cjson.encode({typ, res}))
            ';
        }
    }

Une sortie typique de l'emplacement /test défini ci-dessus est :

lu : ["header",["Content-Disposition","form-data; name=\"file1\"; filename=\"a.txt\"","Content-Disposition: form-data; name=\"file1\"; filename=\"a.txt\""]]
lu : ["header",["Content-Type","text\/plain","Content-Type: text\/plain"]]
lu : ["body","Hello"]
lu : ["body",", wor"]
lu : ["body","ld"]
lu : ["part_end"]
lu : ["header",["Content-Disposition","form-data; name=\"test\"","Content-Disposition: form-data; name=\"test\""]]
lu : ["body","value"]
lu : ["body","\r\n"]
lu : ["part_end"]
lu : ["eof"]
lu : ["eof"]

Vous pouvez utiliser la bibliothèque lua-resty-string pour calculer le hachage SHA-1 et MD5 des données de fichiers de manière incrémentielle. Voici un exemple :

    local resty_sha1 = require "resty.sha1"
    local upload = require "resty.upload"

    local chunk_size = 4096
    local form = upload:new(chunk_size)
    local sha1 = resty_sha1:new()
    local file
    while true do
        local typ, res, err = form:read()

        if not typ then
             ngx.say("échec de la lecture : ", err)
             return
        end

        if typ == "header" then
            local file_name = my_get_file_name(res)
            if file_name then
                file = io.open(file_name, "w+")
                if not file then
                    ngx.say("échec d'ouverture du fichier ", file_name)
                    return
                end
            end

         elseif typ == "body" then
            if file then
                file:write(res)
                sha1:update(res)
            end

        elseif typ == "part_end" then
            file:close()
            file = nil
            local sha1_sum = sha1:final()
            sha1:reset()
            my_save_sha1_sum(sha1_sum)

        elseif typ == "eof" then
            break

        else
            -- ne rien faire
        end
    end

Si vous souhaitez calculer des sommes MD5 pour les fichiers téléchargés, utilisez simplement le module resty.md5 fourni par la bibliothèque lua-resty-string. Il a une API similaire à resty.sha1.

Pour le téléchargement de gros fichiers, il est important de ne pas mettre en mémoire tampon toutes les données. C'est-à-dire que vous ne devez jamais accumuler des morceaux de données dans une énorme chaîne Lua ou dans une énorme table Lua. Vous devez écrire le morceau de données dans des fichiers dès que possible et jeter immédiatement le morceau de données (pour permettre au GC Lua de le libérer).

Au lieu d'écrire le morceau de données dans des fichiers (comme montré dans l'exemple ci-dessus), vous pouvez également écrire les morceaux de données dans des connexions cosocket en amont si vous ne souhaitez pas enregistrer les données sur des systèmes de fichiers locaux.

Utilisation

local upload = require "resty.upload"
local form, err = upload:new(self, chunk_size, max_line_size, preserve_body)
chunk_size est par défaut 4096. C'est la taille utilisée pour lire les données du socket.

max_line_size est par défaut 512. C'est la limite de taille pour lire l'en-tête du corps en morceaux.

Par défaut, lua-resty-upload consommera le corps de la requête. Pour le mode proxy, cela signifie que l'amont ne verra pas le corps. Lorsque preserve_body est défini sur true, le corps de la requête sera préservé. Notez que cette option n'est pas gratuite. Lorsqu'elle est activée, elle doublera l'utilisation de la mémoire de resty.upload.

Voir aussi

GitHub

Vous pouvez trouver des conseils de configuration supplémentaires et de la documentation pour ce module dans le dépôt GitHub pour nginx-module-upload.