Aumentar client_max_body_size no Nginx conf no AWS Elastic Beanstalk

Estou com os erros "413 Request Entity Too Large" ao postar arquivos maiores que 10 MB em nossa API em execução no AWS Elastic Beanstalk.

Pesquisei bastante e acredito que preciso atualizar o client_max_body_size para o Nginx, mas não consigo encontrar nenhuma documentação sobre como fazer isso usando o Elastic Beanstalk. Meu palpite é que ele precisa ser modificado usando um arquivo ebetension.

Alguém tem pensamentos sobre como eu posso até o limite? 10 MB é muito fraco, tem que haver uma maneira de fazer isso manualmente.

Existem dois métodos que você pode usar para isso. Infelizmente, alguns funcionam para alguns tipos de aplicativos EB e outros funcionam para outros.

Suportado / recomendado na documentação da AWS

Para alguns tipos de aplicativos, como Java SE , Go , Node.js e talvez Ruby (não está documentado para Ruby, mas todas as outras plataformas Nginx parecem oferecer suporte a isso), o Elasticbeanstalk possui um entendimento interno de como configurar o Nginx.

Para estender a configuração nginx padrão do Elastic Beanstalk, adicione os arquivos de configuração .conf a uma pasta nomeada .ebextensions/nginx/conf.d/no pacote de origem do aplicativo . A configuração nginx do Elastic Beanstalk inclui arquivos .conf nesta pasta automaticamente.

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

Configurando o Proxy Reverso - Java SE

Para aumentar especificamente o tamanho máximo de upload, crie um arquivo .ebextensions/nginx/conf.d/proxy.confconfigurando o tamanho máximo do corpo para o tamanho que você preferir:

client_max_body_size 50M;

Crie o arquivo de configuração do Nginx diretamente

Após muita pesquisa e horas de trabalho com a maravilhosa equipe de suporte da AWS, criei um arquivo de configuração .ebextensionspara complementar a configuração do nginx. Essa alteração permitiu um tamanho maior do corpo da postagem.

Dentro do .ebextensionsdiretório, criei um arquivo chamado 01_files.configcom o seguinte conteúdo:

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

Isso gera um arquivo proxy.conf dentro do diretório /etc/nginx/conf.d. O arquivo proxy.conf simplesmente contém o liner client_max_body_size 20M;que faz o truque.

Observe que, para algumas plataformas, esse arquivo será criado durante a implantação, mas removido em uma fase de implantação posterior.

Você pode especificar outras diretivas descritas na documentação do Nginx.

http://wiki.nginx.org/Configuration

Espero que isso ajude os outros!

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

A resposta acima foi modificada por questões de segurança (e a sintaxe estava errada, veja, duas entradas 'owner:' na YAML), pessoal, por favor, não defina 777 permissões em QUALQUER COISA. A menos que você goste de ser hackeado e defina o proprietário dos arquivos de configuração do Nginx como root.

Consulte também a resposta abaixo para fazer o nginx capturar essa alteração após a implantação.

EDIT: Depois de implantar uma compilação com as instruções na resposta aceita por Nick Parsons, pode ser necessário reiniciar o servidor nginx para captar as alterações.

Para fazer isso, ssh na instância e faça

sudo service nginx reload

Para saber mais sobre como recarregar, consulte http://nginx.org/en/docs/beginners_guide.html .

Em uma versão anterior do Elastic Beanstalk, consegui adicionar um comando container_ para fazer isso, mas agora estou descobrindo, como @cdmckay, que isso causa uma falha na implantação. Se você reconstruir seu ambiente, ele selecionará as configurações client_max_body_size, contanto que essa instrução esteja no seu arquivo de configuração.

A resposta aceita não funcionou para mim, pois tenho um aplicativo baseado em JVM e parece fazer a configuração do NGINX de maneira diferente. Veria um arquivo proxy.conf sendo criado durante a implantação, mas depois excluído antes da conclusão da implantação. A documentação da AWS explica como configurar o proxy :

Crie um .ebextensions/nginx/conf.d/proxy.confarquivo que contenha apenas a linha:client_max_body_size 40M;

Após a resposta aceita, pode ser necessário recarregar o arquivo de configuração nginx.

Para fazer isso, adicione o seguinte comando

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

Essa seria uma prática melhor do que colocar ssh em sua instância eb e fazê-lo manualmente com um comando.

Isso combinado com a resposta aceita resolveu o mesmo problema para mim. (Trilhos, Puma, NGINX)

A única coisa que funcionou para mim foi criar um arquivo ".config" dentro de .ebextensions como este:

.ebextensions/
           proxy.config

com apenas esse conteúdo no arquivo .config:

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

não há necessidade de subpastas, não há necessidade de reiniciar o servidor de aplicativos, preste atenção que é um arquivo ".config" e não ".conf" dentro de .ebextensions e o uso de indentação adequada para evitar erros no console do aws, o resto é o mesmo não importa o nome do arquivo,

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

A resposta aceita não funcionou para mim, então substituí a configuração nginx por minha própria.

Criei um arquivo chamado nginx.confsob o diretório.ebextensions/nginx/

Eu fiz o SSH em uma instância em execução do meu aplicativo Beanstalk e copiei o conteúdo do nginx.confarquivo, usando cat /etc/nginx/nginx.confe copiando do terminal.

Colei o conteúdo no nginx.confarquivo que criei anteriormente .ebextensions/nginx/e modifiquei a diretiva http para incluir client_max_body_size 50M;. Finalmente reimplantei meu aplicativo usando eb deploye funcionou. Você deve receber a seguinte mensagem durante a implantação:

INFO: Configuração do Nginx detectada no diretório '.ebextensions / nginx'. O AWS Elastic Beanstalk não gerenciará mais a configuração do Nginx para este ambiente.

Este é o conteúdo do meu .ebextensions/nginx/nginx.confarquivo:

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

Não precisei reiniciar o serviço nginx nem o ambiente.

Nota : Verifique se suas .ebextensions fazem parte do arquivo .zip criado e carregado no Beanstalk durante a implantação (não é ignorado .gitignoreou .ebignorese você estiver usando).

Eu tentei todos os .ebextensionsmétodos de adição da configuração no nível de implementação e isso não me ajudou na mais recente Amazon Linux AMI. Eu fiz muita pesquisa e, depois de analisar os logs, posso encontrar o executor de tarefas de implantação .platformprocurando uma pasta chamada everytime e pensei em adicionar uma como as .ebextensions. Abaixo estão as configurações que eu fiz na minha pasta raiz do meu projeto.

Adicione a configuração da pasta abaixo no nível raiz da sua pasta do projeto.

Estrutura da pasta (.platform / nginx / conf.d / proxy.conf)

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

Conteúdo do arquivo 1 - proxy.conf ( .platform/nginx/conf.d/pasta interna )

client_max_body_size 50M;

Conteúdo do arquivo 2 - 00_myconf.config ( .platform/pasta interna )

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

Cuidado completo com as extensões. O primeiro arquivo é .conf e o segundo arquivo é .config .

Agora reimplemente seu projeto no Amazon Elastic Beanstalk e você verá a mágica. Essa configuração será adicionada a todas as suas instâncias do EC2, criadas como parte do dimensionamento automático.

Estrutura detalhada da pasta abaixo.

Esta é a solução fornecida pela AWS e funciona (ajuste o tamanho às suas necessidades)

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

Como alternativa, você pode alterar o servidor proxy para Apache. Para fazer isso, vá para Configuração e edite a configuração do software. A primeira opção aqui é "Servidor Proxy", selecione "Apache".

Para Golang sem Docker, segui estas instruções do aws doc:

Configurando o Proxy Reverso

Se você deseja incluir diretivas além daquelas no bloco http nginx.conf, também pode fornecer arquivos de configuração adicionais no .ebextensions/nginx/conf.d/diretório do seu pacote configurável de origem. Todos os arquivos neste diretório devem ter a extensão .conf. http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/go-environment.html#go-complex-apps

Eu criei o arquivo proxy.confna .ebextensions/nginx/conf.d/raiz do meu projeto, com apenas uma linha dentro:

client_max_body_size 20M;

Se ainda assim não funcionar, verifique se a .ebextensionspasta e as subpastas estão incluídas no zip de implantação. Não há necessidade de reiniciar o Nginx manualmente.

Eu estava lutando com o mesmo problema, mas não consegui resolvê-lo, finalmente está funcionando.

aqui está o meu arquivo 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"

A questão era,

Eu estava usando um script python para o pipeline de código que não inclui a pasta .ebextensions ao criar a compilação.

Aqui estão meus poucos centavos,

1. verifique se a pasta .ebextensions está incluída na pasta zip da sua compilação, localizada no s3bucket da sua conta do aws
2. verifique se ele não está no arquivo .gitignore
3. se você estiver usando um script para gerar a compilação, inclua .ebextensions

Depois de três longos dias tentando descobrir isso, liguei para a incrível equipe de suporte da AWS e eles me deram algumas dicas sobre como resolvê-lo. Primeiro, meu projeto está em JAVA e eu uso o maven e a boot para executá-lo no Elastic Beanstalk (EBS).

1. Conforme explicado na documentação da AWS , você precisa ter as configurações personalizadas do nginx armazenadas no nível raiz do seu projeto. Para fazer isso, criei um arquivo client_max_body_size.conf e o coloquei no seguinte caminho: myprojectname /src/main/resources/ebextensions/nginx/conf.d/client_max_body_size.conf Este arquivo contém apenas a seguinte linha:

   client_max_body_size 10M;
   

2. Configure o maven para adicionar este arquivo na pasta raiz do meu projeto durante a compilação. Isso foi um pouco complicado, eu precisava adicionar a seguinte configuração ( fonte ) no meu 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. Agora você já pode criar seu projeto localmente e executar o seguinte comando SSH para validar se ele está realmente localizado na raiz do seu projeto:

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

4. Agora é a parte complicada. Quando você faz o upload para o EBS, seu arquivo deve conter apenas o arquivo SNAPSHOT.jar e a pasta .ebextensions. Por exemplo, se agora você compactar o arquivo jar e a pasta e carregá-lo manualmente, ele funcionará!

5. Como estou usando o Jenkins para minha implantação e, especificamente, o AWS EBS Deployment Plugin - é necessário alterar as configurações dos arquivos / pastas incluídos na implantação. Agora, por algum motivo, não consegui incluir a pasta .ebextensions, apenas excluí todo o resto, exceto a pasta e o arquivo .jar.

Isso funciona!

Além de client_max_body_size, eu tive que adicionar client_body_buffer_size . Aqui está o arquivo de configuração do ponto que funcionou, para um anexo de 2 MB:

arquivos: "/etc/nginx/conf.d/proxy.conf":
mode: "000755"
proprietário:
grupo raiz
: conteúdo raiz : |
proxy_buffering;
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 plataforma Java

Para criar o arquivo proxy de configuração NGINX, basta adicionar

.ebextension/nginx/conf.d/proxy.conf Arquivo

com o conteúdo client_max_body_size 20M;nele.

"proxy.conf" será implantado em "/etc/nginx/conf.d/proxy.conf" e incluído automaticamente pela configuração do NGINX.

Se você estiver executando o EC2 e instalou o nginx, sua melhor solução é criar um novo arquivo no

/etc/nginx/conf.d

pasta:

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

e adicione a seguinte linha lá:

client_max_body_size 20M;

salve e reinicie o nginx:

sudo systemctl restart nginx