Aumento de client_max_body_size en Nginx conf en AWS Elastic Beanstalk

Me encuentro con errores "413 Request Entity Too Large" al publicar archivos de más de 10 MB en nuestra API que se ejecuta en AWS Elastic Beanstalk.

He investigado bastante y creo que necesito aumentar el tamaño de client_max_body_size para Nginx, sin embargo, parece que no puedo encontrar ninguna documentación sobre cómo hacer esto usando Elastic Beanstalk. Supongo que debe modificarse utilizando un archivo de extensión.

¿Alguien tiene alguna idea sobre cómo puedo superar el límite? 10 MB es bastante débil, tiene que haber una forma de aumentar esto manualmente.

Hay dos métodos que puede utilizar para ello. Desafortunadamente, algunos funcionan para algunos tipos de aplicaciones de EB y algunos funcionan para otros.

Compatible / recomendado en la documentación de AWS

Para algunos tipos de aplicaciones, como Java SE , Go , Node.js y tal vez Ruby (no está documentado para Ruby, pero todas las demás plataformas Nginx parecen admitir esto), Elasticbeanstalk tiene una comprensión incorporada de cómo configurar Nginx.

Para extender la configuración nginx predeterminada de Elastic Beanstalk, agregue los archivos de configuración .conf a una carpeta nombrada .ebextensions/nginx/conf.d/en el paquete fuente de su aplicación . La configuración nginx de Elastic Beanstalk incluye archivos .conf en esta carpeta automáticamente.

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

Configuración del proxy inverso - Java SE

Para aumentar el tamaño máximo de carga específicamente, cree un archivo al .ebextensions/nginx/conf.d/proxy.confestablecer el tamaño máximo del cuerpo al tamaño que prefiera:

client_max_body_size 50M;

Cree el archivo de configuración de Nginx directamente

Después de mucha investigación y horas de trabajo con el maravilloso equipo de soporte de AWS, creé un archivo de configuración dentro .ebextensionspara complementar la configuración de nginx. Este cambio permitió un tamaño de cuerpo de poste más grande.

Dentro del .ebextensionsdirectorio, creé un archivo llamado 01_files.configcon el siguiente contenido:

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

Esto genera un archivo proxy.conf dentro del directorio /etc/nginx/conf.d. El archivo proxy.conf simplemente contiene la línea client_max_body_size 20M;que hace el truco.

Tenga en cuenta que para algunas plataformas, este archivo se creará durante la implementación, pero luego se eliminará en una fase de implementación posterior.

Puede especificar otras directivas que se describen en la documentación de Nginx.

http://wiki.nginx.org/Configuration

¡Espero que esto ayude a otros!

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

Modificó la respuesta anterior por motivos de seguridad (y la sintaxis era incorrecta, vea, dos entradas 'propietario:' en el YAML), muchachos, no establezcan 777 permisos en NADA. A menos que le guste ser pirateado y establezca el propietario de los archivos de configuración de Nginx en root.

También vea la respuesta a continuación para hacer que nginx recoja este cambio después de la implementación.

EDITAR: después de haber implementado una compilación con las instrucciones en la respuesta aceptada por Nick Parsons, es posible que deba reiniciar el servidor nginx para recoger los cambios.

Para hacer esto, ssh a la instancia y haz

sudo service nginx reload

Para obtener más información sobre la recarga, consulte http://nginx.org/en/docs/beginners_guide.html .

En una versión anterior de Elastic Beanstalk, pude agregar un container_command para lograr esto, pero ahora encuentro, como @cdmckay, que esto causa una falla de implementación. Si reconstruye su entorno, recogerá la configuración de client_max_body_size y siempre que esa instrucción esté en su archivo de configuración.

La respuesta aceptada no funcionó para mí ya que tengo una aplicación basada en JVM y parece que la configuración de NGINX es diferente. Vería que se creaba un archivo proxy.conf durante la implementación, pero luego se eliminaba antes de que se completara la implementación. La documentación de AWS explica cómo configurar el proxy :

Cree un .ebextensions/nginx/conf.d/proxy.confarchivo que contenga solo la línea:client_max_body_size 40M;

Después de la respuesta aceptada, es posible que deba volver a cargar el archivo de configuración nginx.

Para hacer esto agregue el siguiente comando

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

Esta sería una mejor práctica que hacer ssh en su instancia eb y hacerlo manualmente con un comando.

Esto, combinado con la respuesta aceptada, resolvió el mismo problema para mí. (Rails, Puma, NGINX)

Lo único que funcionó para mí fue crear un archivo ".config" dentro de .ebextensions como este:

.ebextensions/
           proxy.config

con solo este contenido en el archivo .config:

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

no hay necesidad de subcarpetas, no es necesario reiniciar el servidor de aplicaciones, preste atención a que es un archivo ".config" no ".conf" dentro de .ebextensions y el uso de la sangría adecuada para evitar errores en la consola aws, el resto es el mismo no importa el nombre del archivo,

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

He probado todos los .ebextensionsmétodos para agregar la configuración del nivel de implementación y no me ayudó en la última AMI de Amazon Linux. He investigado mucho y, después de revisar los registros, puedo encontrar que el ejecutor de tareas de implementación está buscando una carpeta llamada .platformcada vez y pensé en agregar una como .ebextensions. A continuación se muestra la configuración que hice en mi carpeta raíz de mi proyecto.

Agregue la siguiente configuración de carpeta en el nivel raíz de la carpeta de su proyecto.

Estructura de carpetas (.platform / nginx / conf.d / proxy.conf)

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

Contenido del archivo 1: proxy.conf ( .platform/nginx/conf.d/carpeta interior )

client_max_body_size 50M;

Contenido del archivo 2 - 00_myconf.config ( .platform/carpeta interior )

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

Cuida bien las extensiones. El primer archivo es .conf y el segundo archivo es .config .

Ahora vuelva a implementar su proyecto en Amazon Elastic Beanstalk y verá la magia. Esta configuración se agregará a todas sus instancias EC2, creadas como parte del escalado automático.

Estructura de carpetas detallada a continuación.

La respuesta aceptada no funcionó para mí, así que anulé la configuración de nginx con la mía.

Creé un archivo llamado nginx.confbajo el directorio.ebextensions/nginx/

Hice SSH en una instancia en ejecución de mi aplicación Beanstalk y copié el contenido del nginx.confarchivo, usando cat /etc/nginx/nginx.confy copiando desde la terminal.

Pegué el contenido en el nginx.confarchivo que creé anteriormente .ebextensions/nginx/y modifiqué la directiva http para incluir client_max_body_size 50M;. Finalmente volví a implementar mi aplicación usando eb deployy funcionó. Debería recibir el siguiente mensaje durante la implementación:

INFO: Configuración de Nginx detectada en el directorio '.ebextensions / nginx'. AWS Elastic Beanstalk ya no administrará la configuración de Nginx para este entorno.

Estos son los contenidos de mi .ebextensions/nginx/nginx.confarchivo:

# 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;
}

No tuve que reiniciar el servicio nginx ni el entorno.

Nota : asegúrese de que su .ebextensions sea parte del archivo .zip creado y cargado en Beanstalk durante la implementación (no se ignora en .gitignoreo .ebignoresi lo está usando).

Esta es la solución proporcionada por AWS y funciona (ajuste el tamaño a sus necesidades)

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

Alternativamente, puede cambiar el servidor proxy a Apache. Para hacer esto, vaya a la Configuración y Edite la Configuración del Software. La primera opción aquí es "Servidor proxy", seleccione "apache".

Para Golang sin Docker, seguí estas instrucciones de aws doc:

Configuración del proxy inverso

Si desea incluir directivas además de las del bloque http nginx.conf, también puede proporcionar archivos de configuración adicionales en el .ebextensions/nginx/conf.d/directorio de su paquete fuente. Todos los archivos de este directorio deben tener la extensión .conf. http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/go-environment.html#go-complex-apps

Creé el archivo proxy.confen .ebextensions/nginx/conf.d/la raíz de mi proyecto, con solo 1 línea dentro:

client_max_body_size 20M;

Si aún no funciona, asegúrese de que la .ebextensionscarpeta y las subcarpetas estén incluidas en su zip de implementación. No es necesario reiniciar Nginx manualmente.

Estaba luchando con el mismo problema pero no pude resolverlo, finalmente está funcionando.

aquí está mi archivo 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"

El problema era

Estaba usando un script de Python para la canalización de código que no incluye la carpeta .ebextensions al crear la compilación.

Aquí están mis pocos centavos

1. asegúrese de que su carpeta .ebextensions esté incluida en la carpeta zip de su compilación, que se encuentra en s3bucket de su cuenta aws
2. asegúrese de que no esté en el archivo .gitignore
3. si está utilizando un script para generar la compilación, asegúrese de que incluya .ebextensions

Después de 3 largos días tratando de resolver este problema, respondí a una llamada con el increíble equipo de soporte de AWS y me dieron algunas pistas sobre cómo resolverlo. Primero, mi proyecto está en JAVA y uso maven y spring boot para ejecutarlo a través de Elastic Beanstalk (EBS).

1. Como se explica en la documentación de AWS , debe tener la configuración nginx personalizada almacenada en el nivel raíz de su proyecto. Para hacer eso, he creado un archivo client_max_body_size.conf y lo coloqué en la siguiente ruta: myprojectname /src/main/resources/ebextensions/nginx/conf.d/client_max_body_size.conf Este archivo contiene solo la siguiente línea:

   client_max_body_size 10M;
   

2. Configure maven para agregar este archivo en la carpeta raíz de mi proyecto durante la compilación. Esto fue un poco complicado, necesitaba agregar la siguiente configuración ( fuente ) en mi 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. Ahora ya puede construir su proyecto localmente y ejecutar el siguiente comando SSH para validar que realmente se encuentra en la raíz de su proyecto:

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

4. Ahora es la parte complicada. Cuando lo sube a EBS, su archivo debe contener solo el archivo SNAPSHOT.jar y la carpeta .ebextensions. Por ejemplo, si ahora comprime el archivo jar y la carpeta y los carga manualmente, ¡funcionará!

5. Dado que estoy usando Jenkins para mi implementación, y específicamente el complemento de implementación de AWS EBS , debe cambiar la configuración de los archivos / carpetas que incluye en la implementación. Ahora, por alguna razón, no pude incluir la carpeta .ebextensions, así que excluí todo lo demás, excepto la carpeta y el archivo .jar.

¡Esto funciona!

Además de client_max_body_size, tuve que agregar client_body_buffer_size . Aquí está el archivo de configuración de puntos que funcionó, para un archivo adjunto de 2 MB:

archivos: "/etc/nginx/conf.d/proxy.conf":
modo: "000755"
propietario:
grupo raíz
: contenido raíz : |
proxy_buffering activado;
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;

Para la plataforma Java

Para crear el archivo proxy de configuración de NGINX, solo debe agregar

.ebextension/nginx/conf.d/proxy.conf expediente

con el contenido client_max_body_size 20M; en él.

"proxy.conf" se implementará en "/etc/nginx/conf.d/proxy.conf" y se incluirá automáticamente en la configuración de NGINX.

Si está ejecutando EC2 e instaló nginx usted mismo, su mejor solución es crear un nuevo archivo en

/etc/nginx/conf.d

carpeta:

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

y luego agregue la siguiente línea allí:

client_max_body_size 20M;

luego guarde y reinicie nginx:

sudo systemctl restart nginx