Aumento client_max_body_size in Nginx conf su AWS Elastic Beanstalk

Mi imbatto in "413 Request Entity Too Large" errori durante la pubblicazione di file più grandi di 10 MB nella nostra API in esecuzione su AWS Elastic Beanstalk.

Ho fatto un bel po 'di ricerche e credo che sia necessario aumentare il client_max_body_size per Nginx, tuttavia non riesco a trovare alcuna documentazione su come farlo utilizzando Elastic Beanstalk. La mia ipotesi è che debba essere modificato utilizzando un file ebetension.

Qualcuno ha pensieri su come posso aumentare il limite? 10 MB sono piuttosto deboli, deve esserci un modo per aumentarlo manualmente.

Ci sono due metodi che puoi adottare per questo. Purtroppo alcuni funzionano per alcuni tipi di applicazioni EB e alcuni funzionano per altri.

Supportato / consigliato nella documentazione AWS

Per alcuni tipi di applicazioni, come Java SE , Go , Node.js e forse Ruby (non è documentato per Ruby, ma tutte le altre piattaforme Nginx sembrano supportarlo), Elasticbeanstalk ha una comprensione integrata di come configurare Nginx.

Per estendere la configurazione nginx predefinita di Elastic Beanstalk, aggiungi i file di configurazione .conf a una cartella denominata .ebextensions/nginx/conf.d/nel bundle di origine dell'applicazione . La configurazione nginx di Elastic Beanstalk include automaticamente i file .conf in questa cartella.

~/workspace/my-app/
|-- .ebextensions
|   `-- nginx
|       `-- conf.d
|           `-- myconf.conf
`-- web.jar

Configurazione del proxy inverso - Java SE

Per aumentare la dimensione massima di caricamento in modo specifico, crea un file .ebextensions/nginx/conf.d/proxy.confimpostando la dimensione massima del corpo su qualsiasi dimensione preferisci:

client_max_body_size 50M;

Crea direttamente il file di configurazione di Nginx

Dopo molte ricerche e ore di lavoro con il meraviglioso team di supporto AWS, ho creato un file di configurazione all'interno di .ebextensions per integrare la configurazione di nginx. Questa modifica ha consentito una maggiore dimensione del corpo del post.

All'interno della .ebextensionsdirectory ho creato un file chiamato 01_files.configcon il seguente contenuto:

files:
    "/etc/nginx/conf.d/proxy.conf" :
        mode: "000755"
        owner: root
        group: root
        content: |
           client_max_body_size 20M;

Questo genera un file proxy.conf all'interno della directory /etc/nginx/conf.d. Il file proxy.conf contiene semplicemente l'unico linerclient_max_body_size 20M; che fa il trucco.

Si noti che per alcune piattaforme, questo file verrà creato durante la distribuzione, ma poi rimosso in una fase di distribuzione successiva.

È possibile specificare altre direttive descritte nella documentazione di Nginx.

http://wiki.nginx.org/Configuration

Spero che questo aiuti gli altri!

files:
    "/etc/nginx/conf.d/proxy.conf" :
        mode: "000755"
        owner: root
        group: root
        content: |
           client_max_body_size 20M;

Modificata la risposta sopra per motivi di sicurezza (e la sintassi era sbagliata, vedi due voci "owner:" nello YAML), ragazzi, per favore non impostate i permessi 777 su NULLA. A meno che non ti piaccia essere hackerato e imposti il ​​proprietario dei file di configurazione di Nginx su root.

Vedi anche la risposta seguente per fare in modo che nginx prenda questa modifica dopo la distribuzione.

MODIFICA: dopo aver distribuito una build con le istruzioni nella risposta accettata di Nick Parsons, potrebbe essere necessario riavviare il server nginx per acquisire le modifiche.

Per fare questo, ssh all'istanza e fai

sudo service nginx reload

Per ulteriori informazioni sul ricaricamento, vedere http://nginx.org/en/docs/beginners_guide.html .

In una versione precedente di Elastic Beanstalk, ero in grado di aggiungere un container_command per eseguire questa operazione, ma ora sto scoprendo, come @cdmckay, che ciò causa un errore di distribuzione. Se ricostruisci il tuo ambiente, raccoglierà le impostazioni client_max_body_size così come l'istruzione è nel tuo file di configurazione.

La risposta accettata non ha funzionato per me poiché ho un'app basata su JVM e sembra che la configurazione di NGINX sia diversa. Vorrei vedere un file proxy.conf creato durante la distribuzione, ma poi cancellato prima del completamento della distribuzione. La documentazione di AWS spiega come configurare il proxy :

Crea un .ebextensions/nginx/conf.d/proxy.conffile che contenga solo la riga:client_max_body_size 40M;

A seguito della risposta accettata, potrebbe essere necessario ricaricare il file di configurazione nginx.

Per fare ciò aggiungi il seguente comando

   container_commands:
      01_reload_nginx:
        command: "service nginx reload"

Questa sarebbe una pratica migliore che eseguire ssh'ing nella tua istanza eb e farlo manualmente con un comando.

Questo combinato con la risposta accettata ha risolto lo stesso problema per me. (Rails, Puma, NGINX)

L'unica cosa che ha funzionato per me è stata creare un file ".config" all'interno di .ebextensions come questo:

.ebextensions/
           proxy.config

con solo questo contenuto nel file .config:

files:
  "/etc/nginx/conf.d/proxy.conf":
     content: |
       client_max_body_size 50M;

non c'è bisogno di sottocartelle, non c'è bisogno di riavviare il server delle applicazioni, prestare attenzione che è un file ".config" non ".conf" all'interno di .ebextensions e l'uso del rientro appropriato per evitare errori nella console aws il resto è lo stesso non importa il nome del file,

grazie a: http://kroltech.com/2014/09/14/quick-tip-increase-upload-size-in-aws-elastic-beanstalk-node-js-env/

Ho provato tutti i .ebextensionsmetodi per aggiungere la configurazione a livello di implementazione e non mi ha aiutato nell'ultima AMI Amazon Linux. Ho fatto molte ricerche e dopo aver esaminato i registri posso trovare che il runner dell'attività di distribuzione sta cercando una cartella chiamata.platform dell'attività di ogni volta e ho pensato di aggiungerne una proprio come .ebextensions. Di seguito sono riportate le impostazioni che ho eseguito nella mia cartella principale del mio progetto.

Aggiungi la configurazione della cartella sottostante nel livello principale della cartella del tuo progetto.

Struttura delle cartelle (.platform / nginx / conf.d / proxy.conf)

.platform/
         nginx/
              conf.d/
                    proxy.conf
         00_myconf.config

Contenuto del file 1 - proxy.conf (all'interno della .platform/nginx/conf.d/cartella)

client_max_body_size 50M;

Contenuto del file 2 - 00_myconf.config (all'interno della .platform/cartella)

container_commands:
  01_reload_nginx:
    command: "service nginx reload"

Prenditi cura delle estensioni. Il primo file è .conf e il secondo file è .config .

Ora ridistribuisci il tuo progetto su Amazon Elastic Beanstalk e vedrai la magia. Questa configurazione verrà aggiunta a tutte le istanze EC2, create come parte del ridimensionamento automatico.

Struttura delle cartelle dettagliata di seguito.

La risposta accettata non ha funzionato per me, quindi ho sovrascritto la configurazione di nginx con la mia.

Ho creato un file chiamato nginx.confsotto la directory.ebextensions/nginx/

Sono entrato in un'istanza in esecuzione della mia app Beanstalk tramite SSH e ho copiato il contenuto del nginx.conffile, utilizzando cat /etc/nginx/nginx.confe copiando dal terminale.

Ho incollato il contenuto nel nginx.conffile precedentemente creato .ebextensions/nginx/e ho modificato la direttiva http in modo che includesse client_max_body_size 50M;. Alla fine ho ridistribuito la mia app usando eb deploye ha funzionato. Dovresti ricevere il seguente messaggio durante la distribuzione:

INFORMAZIONI: configurazione di Nginx rilevata nella directory ".ebextensions / nginx". AWS Elastic Beanstalk non gestirà più la configurazione Nginx per questo ambiente.

Questi sono i contenuti del mio .ebextensions/nginx/nginx.conffile:

# Elastic Beanstalk Nginx Configuration File

user                    nginx;
error_log               /var/log/nginx/error.log warn;
pid                     /var/run/nginx.pid;
worker_processes        auto;
worker_rlimit_nofile    33193;

events {
    worker_connections  1024;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    include       conf.d/*.conf;

    map $http_upgrade $connection_upgrade {
        default     "upgrade";
    }

    server {
        listen        80 default_server;
        access_log    /var/log/nginx/access.log main;

        client_header_timeout 60;
        client_body_timeout   60;
        keepalive_timeout     60;
        gzip                  off;
        gzip_comp_level       4;
        gzip_types text/plain text/css application/json application/javascript application/x-javascript text/xml application/xml application/xml+rss text/javascript;

        # Include the Elastic Beanstalk generated locations
        include conf.d/elasticbeanstalk/*.conf;
    }

    client_max_body_size 50M;
}

Non ho dovuto riavviare il servizio nginx né l'ambiente.

Nota : assicurati che il tuo .ebextensions faccia parte del file .zip creato e caricato su Beanstalk durante la distribuzione (non viene ignorato .gitignoreo .ebignorese lo stai utilizzando).

Questa è la soluzione fornita da AWS e funziona (adatta le dimensioni alle tue esigenze)

files:
  "/opt/elasticbeanstalk/hooks/appdeploy/enact/12_add_nginx_configuration.sh":
    mode: "000755"
    owner: root
    group: root
    content: |
      #!/usr/bin/env bash
      /bin/echo "client_max_body_size 50M;" > /etc/nginx/conf.d/proxy.conf
      /sbin/service nginx reload

In alternativa puoi cambiare il server proxy in Apache. Per fare ciò, vai su Configurazione e Modifica la configurazione del software. La prima opzione qui è "Server proxy", seleziona "apache".

Per Golang senza Docker ho seguito queste istruzioni da aws doc:

Configurazione del proxy inverso

Se vuoi includere direttive oltre a quelle nel blocco http nginx.conf, puoi anche fornire file di configurazione aggiuntivi nella .ebextensions/nginx/conf.d/directory del tuo bundle sorgente. Tutti i file in questa directory devono avere l'estensione .conf. http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/go-environment.html#go-complex-apps

Ho creato il file proxy.confnella .ebextensions/nginx/conf.d/radice del mio progetto, con semplicemente 1 riga all'interno:

client_max_body_size 20M;

Se ancora non funziona, assicurati che la .ebextensionscartella e le sottocartelle siano incluse nel tuo zip di distribuzione. Non è necessario riavviare Nginx manualmente.

Stavo lottando con lo stesso problema ma non sono riuscito a risolverlo, finalmente funziona.

ecco il mio file congfig,

files:
  "/etc/nginx/conf.d/01_proxy.conf":
    mode: "000755"
    owner: root
    group: root
    content: |
      client_max_body_size 50M;
      client_body_buffer_size 16k;

container_commands:
  01_reload_nginx:
    command: "sudo service nginx reload"

Il problema era,

Stavo usando uno script Python per la pipeline di codice che non include la cartella .ebextensions durante la creazione della build.

Ecco i miei pochi centesimi,

1. assicurati che la tua cartella .ebextensions sia inclusa nella cartella zip della build che si trova in s3bucket del tuo account aws
2. assicurati che non sia nel file .gitignore
3. se stai usando uno script per generare la build assicurati che includa .ebextensions

Dopo 3 lunghi giorni passati a cercare di capire questo, ho risposto a una chiamata con il fantastico team di supporto AWS e mi hanno dato alcuni indizi su come risolverlo. Innanzitutto, il mio progetto è in JAVA e utilizzo Maven e Spring Boot per eseguirlo tramite Elastic Beanstalk (EBS).

1. Come spiegato nella documentazione di AWS , è necessario che le impostazioni di nginx personalizzate siano archiviate nel livello principale del progetto. Per farlo ho creato un file client_max_body_size.conf e l'ho inserito nel seguente percorso: myprojectname /src/main/resources/ebextensions/nginx/conf.d/client_max_body_size.conf Questo file contiene solo la seguente riga:

   client_max_body_size 10M;
   

2. Configura Maven per aggiungere questo file nella cartella principale del mio progetto durante la compilazione. Questo è stato un po 'complicato, avevo bisogno di aggiungere la seguente configurazione ( sorgente ) nel mio POM.xml:

   <plugin>
   <artifactId>maven-resources-plugin</artifactId>
   <version>3.1.0</version>
   <executions>
       <execution>
           <id>copy-resources</id>
           <!-- here the phase you need -->
           <phase>validate</phase>
           <goals>
               <goal>copy-resources</goal>
           </goals>
           <configuration>
               <outputDirectory>${basedir}/target/.ebextensions</outputDirectory>
               <resources>
                   <resource>
                       <directory>src/main/resources/ebextensions</directory>
                       <filtering>true</filtering>
                   </resource>
               </resources>
           </configuration>
       </execution>
   </executions>
   

3. Ora puoi già creare il tuo progetto localmente ed eseguire il seguente comando SSH per convalidare che si trova effettivamente nella radice del tuo progetto:

   jar tf main-1.0-SNAPSHOT.jar | grep .ebextensions
   

4. Adesso è la parte difficile. Quando lo carichi su EBS, il tuo file dovrebbe contenere solo il file SNAPSHOT.jar e la cartella .ebextensions. Ad esempio, se ora comprimerai il file jar e la cartella e lo caricherai manualmente, funzionerà!

5. Poiché utilizzo Jenkins per la mia distribuzione, e in particolare il plug-in di distribuzione AWS EBS , devi modificare le impostazioni dei file / della cartella che includi nella distribuzione. Ora per qualche motivo non sono stato in grado di includere la cartella .ebextensions, quindi ho escluso tutto il resto tranne la cartella e il file .jar.

Funziona!

Oltre a client_max_body_size, ho dovuto aggiungere client_body_buffer_size . Ecco il file di configurazione del punto che ha funzionato, per un allegato da 2 MB:

file: "/etc/nginx/conf.d/proxy.conf":
modalità: "000755"
proprietario:
gruppo root
: contenuto root : |
proxy_buffering attivo;
proxy_buffer_size 128k;
proxy_buffers 8 256k;
client_body_buffer_size 2M;
proxy_busy_buffers_size 256k;
fastcgi_buffers 16 16k;
fastcgi_buffer_size 32k;
client_max_body_size 3M;

Per la piattaforma Java

Per creare il file proxy di configurazione NGINX devi semplicemente aggiungere

.ebextension/nginx/conf.d/proxy.conf file

con il contenuto client_max_body_size 20M;in esso.

"proxy.conf" verrà distribuito in "/etc/nginx/conf.d/proxy.conf" e automaticamente incluso dalla configurazione di NGINX.

Se stai eseguendo EC2 e hai installato nginx da solo, la soluzione migliore è creare un nuovo file in formato

/etc/nginx/conf.d

cartella:

sudo nano /etc/nginx/conf.d/proxy.conf

e quindi aggiungi la seguente riga lì:

client_max_body_size 20M;

quindi salva e riavvia nginx:

sudo systemctl restart nginx