Parece que no puedo forzar https en el nivel de uso gratuito de elastic beanstalk.

Probé la siguiente sugerencia en Cómo forzar https en amazon elastic beanstalk sin fallar la verificación de estado

Usando esta regla de reescritura de Apache

RewriteEngine On
RewriteCond %{HTTP:X-Forwarded-Proto} !https
RewriteCond %{REQUEST_URI} !^/status$ 
RewriteCond %{REQUEST_URI} !^/version$ 
RewriteCond %{REQUEST_URI} !^/_hostmanager/ 
RewriteRule . https://%{SERVER_NAME}%{REQUEST_URI} [L,R]

Cuando intento eso, las solicitudes http no se redirigen a https como me gustaría. En cambio, la página http se carga normalmente. También intenté usar el encabezado X-Fordered-Port con el mismo resultado.

También probé la siguiente regla de reescritura

RewriteCond %{SERVER_PORT} 80
RewriteRule . https://%{SERVER_NAME}%{REQUEST_URI} [L,R]

Y esta regla provoca un bucle de redireccionamiento. Por lo tanto, parece que las reglas de reescritura de Apache no recogen los encabezados de Elastic Load Balancer X-Fordered-Port y X-Fordered-Proto, pero tampoco un bucle de redireccionamiento tampoco es lo que busco.

Por favor ayuda. Soy nuevo en AWS, Elastic Beanstalk y no estoy muy familiarizado con las reglas de Apache. No estoy muy seguro de adónde ir desde aquí. Gracias.

Esta respuesta supone que ya habilitó https en el grupo de seguridad del balanceador de carga, agregó el certificado SSL al balanceador de carga, el balanceador de carga reenvió los puertos 80 y 443 y apuntó su nombre de dominio al entorno Elastic Beanstalk con Route 53 (o servicio DNS equivalente).

NOTA: Esta respuesta es para entornos de Elastic Beanstalk que usan Apache. Es posible que no funcione para una implementación basada en Docker.

Todo lo que necesita hacer es agregar lo siguiente a uno de sus .configarchivos en el .ebextensionsdirectorio de su proyecto :

files:
    "/etc/httpd/conf.d/ssl_rewrite.conf":
        mode: "000644"
        owner: root
        group: root
        content: |
            RewriteEngine On
            <If "-n '%{HTTP:X-Forwarded-Proto}' && %{HTTP:X-Forwarded-Proto} != 'https'">
            RewriteRule (.*) https://%{HTTP_HOST}%{REQUEST_URI} [R,L]
            </If>

Explicación

Esto es moderadamente sencillo fuera de Elastic Beanstalk. Por lo general, se agrega una regla de reescritura de Apache como la siguiente:

RewriteCond %{HTTPS} off
RewriteRule (.*) https://%{HTTP_HOST}%{REQUEST_URI}

O, si está detrás de un equilibrador de carga, como estamos en este caso:

RewriteCond %{HTTP:X-Forwarded-Proto} !https
RewriteRule (.*) https://%{HTTP_HOST}%{REQUEST_URI} [R,L]

Sin embargo, estas configuraciones solo funcionan dentro de un <VirtualHost>bloque. Cambiar RewriteConda un <If>bloque permite que funcione correctamente fuera de un <VirtualHost>bloque, lo que nos permite instalar un archivo de configuración de Apache independiente. Tenga en cuenta que la configuración estándar de Apache en CentOS (incluida la configuración en ElasticBeanstalk) incluye todos los archivos que coinciden /etc/httpd/conf.d/*.conf, lo que coincide con la ruta del archivo donde almacenamos este archivo.

La -n '%{HTTP:X-Forwarded-Proto}'parte de la condición evita que se redirija si no está detrás de un equilibrador de carga, lo que le permite tener una configuración compartida entre un entorno de producción con un equilibrador de carga y https, y un entorno de prueba que es de instancia única y no tiene https. Esto no es necesario si está utilizando balanceadores de carga y https en todos sus entornos, pero no está de más tenerlo.

Malas soluciones que he visto

He visto muchas malas soluciones a este problema, y ​​vale la pena analizarlas para entender por qué es necesaria esta solución.

1. Use Cloudfront: algunas personas sugieren usar la configuración de Cloudfront sin caché frente a Elastic Beanstalk para realizar la redirección de HTTP a HTTPS. Esto agrega un servicio completamente nuevo (lo que agrega complejidad) que no es exactamente apropiado (Cloudfront es una CDN; no es la herramienta adecuada para forzar HTTPS en contenido inherentemente dinámico). La configuración de Apache es la solución normal a este problema y Elastic Beanstalk usa Apache, así que ese es el camino que debemos seguir.

2. SSH en el servidor y ...: Esto es completamente antitético hasta el punto de Elastic Beanstalk y tiene muchos problemas. Las instancias nuevas creadas mediante el ajuste de escala automático no tendrán la configuración modificada. Los entornos clonados no tendrán la configuración. Cualquier cantidad de un conjunto razonable de cambios ambientales eliminará la configuración. Esta es una mala idea.

3. Sobrescriba la configuración de Apache con un nuevo archivo: esto está entrando en el ámbito correcto de la solución, pero lo deja con una pesadilla de mantenimiento si Elastic Beanstalk cambia aspectos de la configuración del servidor (lo que muy bien pueden hacer). Consulte también los problemas en el siguiente elemento.

4. Edite dinámicamente el archivo de configuración de Apache para agregar algunas líneas: esta es una idea decente. El problema con esto es que no funcionará si Elastic Beanstalk alguna vez cambia el nombre de su archivo de configuración Apache predeterminado, y que este archivo se puede sobrescribir cuando menos lo espera: https://forums.aws.amazon.com/thread .jspa? threadID = 163369

EDITAR: Si bien me encanta esta respuesta, ahora es muy antigua . AWS ha creado nuevos servicios (como Certificate Manager ) que hacen que parte de esta respuesta sea obsoleta. Además, usar la .ebextensionscarpeta con Apache es una forma más limpia de manejar esta redirección como se explicó anteriormente.

Si aloja su sitio web en S3, algunas partes de esta respuesta pueden serle útiles.

Esto funcionó para mí:

1. Cargue el certificado en AWS mediante el awscomando de la consola. La estructura de comando es:

   aws iam upload-server-certificate --server-certificate-name CERTIFICATE_NAME --certificate-body "file://PATH_TO_CERTIFICATE.crt" --private-key "file://YOUR_PRIVATE_KEY.pem" --certificate-chain "file://YOUR_CERTIFICATE_CHAIN.ca-bundle" --path /cloudfront/
   

2. En su aplicación Elastic Beanstalk, vaya a Configuración -> Nivel de red -> Equilibrio de carga y haga clic en el icono de engranaje .

3. Seleccione Puerto de escucha seguro como 443 . Seleccione Protocolo como HTTPS . Seleccione CERTIFICATE_NAMEdel paso 2 para el ID del certificado SSL . Guarde la configuración.

4. Ve a tu consola . Haga clic en Instancias EC2 . Haga clic en Load Balancers . Haga clic en los balanceadores de carga. Haga clic en Instancias y desplácese hacia abajo para ver las instancias EC2 asignadas a ese balanceador de carga. Si la instancia EC2 tiene el mismo nombre que la URL de su aplicación (o algo parecido), tome nota del nombre DNS del balanceador de carga. Debe estar en el formatoawseb-e-...

5. Vuelve a tu consola . Haga clic en CloudFront . Haga clic en Crear distribución . Seleccione una distribución web .

6. Configure la distribución. Configure su Nombre de dominio de origen con el nombre DNS del equilibrador de carga que encontró en el paso 5 . Configure la Política de protocolo del visor para redirigir HTTP a HTTPS . Establezca Forward Query Strings en Sí . Establezca Nombres de dominio alternativos (CNAME) en las URL que desea utilizar para su aplicación. Configure el Certificado SSL en el CERTIFICATE_NAMEque cargó en el paso 2 . Crea tu distribución.

7. Haga clic en el nombre de su distribución en CloudFront. Haga clic en Orígenes , seleccione su origen y haga clic en Editar . Asegúrese de que su Política de protocolo de origen sea Visor de coincidencias . Regresa. Haga clic en Comportamientos , seleccione su origen y haga clic en Editar . Cambie Encabezados de reenvío a Lista blanca y agregue Host . Salvar.

Nota: también escribí una guía más larga .

El más votado no funciona para mí ... la directiva <Si> solo funciona con Apache 2.4+, pero ElasticBeanstalk tiene la versión 2.2.x.

Entonces, siguiendo el mismo consejo que el anterior. Cree un archivo llamado .ebextensions / https_rewrite.config con el siguiente contenido

files:
    "/etc/httpd/conf.d/ssl_rewrite.conf":
        mode: "000644"
        owner: root
        group: root
        content: |
            LoadModule rewrite_module modules/mod_rewrite.so
            RewriteEngine On
            # This will enable the Rewrite capabilities
            RewriteCond %{HTTPS} !=on
            # This checks to make sure the connection is not already HTTPS
            RewriteRule ^/?(.*) https://%{SERVER_NAME}/$1 [R,L]

Esto parece funcionar para mí.

Sobre cómo compilar este archivo en su archivo WAR, vea esta respuesta

Con los nuevos Application Load Balancers, ahora puede hacer esto de manera bastante trivial ...

Asegúrese de configurar uno de estos en el momento de configurar un entorno de EB (creo que todavía está predeterminado en el equilibrador de carga clásico). No puede cambiar el tipo una vez creado el entorno, así que vuelva a crearlo

Una vez hecho esto, vaya a la configuración de EC2 -> Load Balancers. Haga clic en el equilibrador de carga que creó para su entorno de EB. Debe asegurarse de haber configurado un oyente HTTPS antes de esta tarea, así que asegúrese de escuchar HTTPS 443 con un certificado SSL y reenviar el tráfico a sus instancias con HTTP en 80.

Luego agregue un nuevo oyente que escuche en HTTP y agregue una acción predeterminada de "Redirigir a:". Asegúrese de configurar HTTPS como protocolo, 443 como puerto, "Host original, ruta, consulta" como opción y finalmente 301 como código de respuesta HTTP.

Una vez que se agrega este oyente, asegúrese de actualizar su grupo de seguridad EC2 Load Balancer para aceptar conexiones HTTPS y HTTP, verá una pequeña señal de advertencia en el oyente para recordarle.

Chris

Editar: la solución de Zags es más general y correcta. Lo recomiendo sobre el mío (que es específico de un env de python)

Aquí hay una solución limpia y rápida que se me ocurrió que evita hackear wsgi.conf o usar CloudFront

En su .ebextensions / some_file.config:

# Redirect HTTP to HTTPS
  "/etc/httpd/conf.d/https_redirect.conf":
    mode: "000644"
    owner: root
    group: root
    content: |
      <Directory /opt/python/current/app/>
      RewriteEngine on
      RewriteCond %{HTTP:X-Forwarded-Proto} ^http$
      RewriteRule .* https://%{HTTP_HOST}%{REQUEST_URI} [R=301,L]
      </Directory>

Siento que esto es demasiado fácil, pero parece estar funcionando bien.

También tenga en cuenta que estoy redirigiendo explícitamente HTTP en lugar de "no HTTPS".

Estoy tratando de redirigir un beanstalk elástico con loadbalancer en 2018. Ninguna de las respuestas anteriores funciona en mi entorno. Varios problemas que encontré:

1. Estaba probando la respuesta más votada, pero mi gato es la versión 2.7. No es compatible.

2. Estaba usando container_commands y copié la configuración 00_applications. AWS simplemente lo ignora.

Así que finalmente lo hice funcionar leyendo esto: https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/java-tomcat-proxy.html

Esto es lo que hago:

Recreé la estructura de la carpeta:

.ebextensions 
 - httpd
  -conf.d
   -ssl.conf

Y luego este es el contenido de ssl.conf

<VirtualHost *:80>
  RewriteEngine on
  RewriteCond %{HTTP:X-Forwarded-Proto} =http
  RewriteRule ^ https://%{HTTP_HOST}%{REQUEST_URI} [L,R=301]
  <Proxy *>
    Order Allow,Deny
    Allow from all
  </Proxy>
  ProxyPass / http://localhost:8080/ retry=0
  ProxyPassReverse / http://localhost:8080/
  ProxyPreserveHost on

  ErrorLog /var/log/httpd/elasticbeanstalk-error_log
</VirtualHost>

Espero que esto ayude.

Me funciona con el siguiente comando:

RewriteCond %{HTTP:X-Forwarded-Port} !=443

y sin la verificación https:

RewriteCond %{HTTP:X-Forwarded-Proto} !https

Parece que ELB cambió el valor de X-Fordered-Proto a http (incluso en el protocolo TCP).

Ninguna de las respuestas anteriores funcionó para mí, pero algunas me ayudaron a descubrir la respuesta que funcionó para mí.También encontré la siguiente URL que ayudó a http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/java-tomcat -platform.html

Creé la estructura de archivos mencionada en la URL anterior para cambiar 2 archivos httpd.conf 00_application.conf

copie el httpd.conf completo de su instancia y colóquelo en su código en .ebextention bajo la estructura de carpetas mencionada en el enlace anterior. Luego, simplemente agregue la siguiente línea a ese archivo en su proyecto

LoadModule rewrite_module modules/mod_rewrite.so

Haga lo mismo para 00_application.conf, cópielo de su instancia y colóquelo en su base de código bajo .ebextention en httpd / conf.d / elasticbeanstalk / 00_application.conf Ahora edite este archivo y agregue lo siguiente entre VirtualHost

RewriteEngine on
RewriteCond %{HTTP:X-Forwarded-Proto} =http
RewriteRule ^ https://%{HTTP_HOST}%{REQUEST_URI} [L,R=301]

Ahora implemente su código. Debería funcionar.

En Elastic Beanstalk, simplemente puede agregar su configuración de modo que AWS sobrescriba la suya, le permitirá sobrescribir la configuración del servidor web y enviar su propia configuración.

Simplemente agregue el siguiente archivo debajo de la ruta: .ebextensions \ httpd \ conf.d

Contenido del archivo:

<VirtualHost *:80>
   LoadModule rewrite_module modules/mod_rewrite.so

   RewriteEngine On
   RewriteCond %{HTTP:X-Forwarded-Proto} !https
   RewriteCond %{HTTP_USER_AGENT} !ELB-HealthChecker
   RewriteRule (.*) https://%{HTTP_HOST}%{REQUEST_URI}

   <Proxy *>
     Order deny,allow
     Allow from all
   </Proxy>

   ProxyPass / http://localhost:8080/ retry=0
   ProxyPassReverse / http://localhost:8080/
   ProxyPreserveHost on

   ErrorLog /var/log/httpd/elasticbeanstalk-error_log

</VirtualHost>

'.Ebextensions' es la carpeta de configuración estándar en AWS y el resto solo apunta a qué archivo y carpeta desea sobrescribir. Si el archivo o carpeta no existe, simplemente créelos.

Tuve dificultades para resolver esto, así que después de que se me ocurrió una solución, escribí una explicación detallada de mi solución para ayudar a alguien más. Esto es específico de la aplicación Tomcat 8, Apache2 y Spring Boot. Hay ejemplos de ebextension realmente útiles en el github de AWS Labs .

Resumen de lo que funcionó para mí:

1. Cree un archivo en /src/main/webapp/.ebextensions/httpd/conf.d/elasticbeanstalk.conf
2. Agregue condiciones / reglas de reescritura teniendo cuidado de incluir "LoadModule rewrite_module modules / mod_rewrite.so"
3. Implementar en AWS EBS

Aquí hay un ejemplo de la aplicación Spring Boot .

Tengo las siguientes configuraciones para beanstalk elásticos (64 bits Amazon Linux 2016.09 v2.3.1 con Tomcat 8 Java 8). Creé un directorio .ebextensions y agregué un archivo .config YAML con las condiciones de reescritura

La solución de Zagas descrita anteriormente (que es muy compleja) no me funciona.

1. Porque la condición "Si" es desconocida
2. Debido a Apache 2.2, no tengo mod_rewrite.so incluido en mi archivo httpd.conf

Esta solución tiene más sentido para mí, pero tampoco funciona. No sucede nada y no puedo ver el archivo "ssl_rewrite.conf" en el directorio "conf.d".

La tercera solución probada fue agregar los archivos "run.config" y "ssl_rewrite.conf" en el directorio ".ebextendsion".

run_config contiene

container_commands:
copy-config:
command: "cp .ebextensions/ssl_rewrite.conf /etc/httpd/conf.d"

ssl_rewrite.conf contiene

LoadModule rewrite_module modules/mod_rewrite.so
RewriteEngine On
RewriteCond %{HTTP:X-Forwarded-Proto} =http
RewriteRule . https://%{HTTP:Host}%{REQUEST_URI} [L,R=permanent]

ssl_rewrite.conf se crea en el directorio "conf.d" pero la redirección de http a https no funciona.

La única solución que funcionó para mí fue agregar las siguientes líneas en "/etc/httpd/conf.d/elasticbeanstalk/00_application.conf"

<VirtualHost *:80>
......
RewriteEngine on
RewriteCond %{HTTP:X-Forwarded-Proto} =http
RewriteRule ^ https://%{HTTP_HOST}%{REQUEST_URI} [L,R=301]
......
</VirtualHost>

pero esta es una solución temporal y si se reemplaza una máquina, mi redirección https desaparece.

En caso de que alguien todavía esté luchando:

He luchado durante algún tiempo y, finalmente, encontré un GitHub (del equipo de AWS) con todas las configuraciones de AWS y el siguiente ejemplo funciona para la redirección HTTP> HTTPS para Apache 2.2. (Para las configuraciones para Apache 2.4 y Nginx, consulte el enlace a continuación).

Apache 2.2

1. Cree un archivo en el directorio raíz de su aplicación: YOUR_PROJECT_ROOT / .ebextensions / httpd / conf.d / elasticbeanstalk.conf (En caso de usar IntelliJ / Java, asegúrese de que se agregue al artefacto .WAR final)

2. Agregue las siguientes líneas para habilitar la redirección en el host virtual:

   <VirtualHost *:80>
       LoadModule rewrite_module modules/mod_rewrite.so
       RewriteEngine On
       RewriteCond %{HTTP:X-Forwarded-Proto} !https
       RewriteCond %{HTTP_USER_AGENT} !ELB-HealthChecker
       RewriteRule (.*) https://%{HTTP_HOST}%{REQUEST_URI}
   
       <Proxy *>
           Order deny,allow
           Allow from all
       </Proxy>
   
       ProxyPass / http://localhost:8080/ retry=0
       ProxyPassReverse / http://localhost:8080/
       ProxyPreserveHost on
   
       ErrorLog /var/log/httpd/elasticbeanstalk-error_log
   </VirtualHost>
   

Para obtener más ejemplos de Apache 2.4 y Nginx, visite este repositorio de GitHub:

https://github.com/awsdocs/elastic-beanstalk-samples/tree/master/configuration-files/aws-provided/security-configuration/https-redirect/java-tomcat

Además, hay muchas más configuraciones útiles y ejemplos disponibles.

Saludos

Habilitación de HTTPS a través de una variable de entorno

Necesitaba hacer cumplir HTTPS solo para nuestro entorno de producción, y no para los de desarrollo y preparación que también están en Elastic Beanstalk pero no usan un balanceador de carga (y por lo tanto no se les puede asignar un certificado directamente).

Utilizo una variable de entorno USE_HTTPS. Copiamos el ssl_rewrite.confarchivo si y solo si USE_HTTPSestá configurado en true.

.ebextensions / files / ssl_rewrite.conf

RewriteEngine On
<If "-n '%{HTTP:X-Forwarded-Proto}' && %{HTTP:X-Forwarded-Proto} != 'https'">
RewriteRule (.*) https://%{HTTP_HOST}%{REQUEST_URI} [R=301,L]
</If>

.ebextensions / https.config

files:
  "/home/ec2-user/https_setup.sh":
    mode: "000755"
    owner: root
    group: root
    content: |
      #!/bin/bash

      echo "USE_HTTPS env var: ${USE_HTTPS,,}"
      outfile=/etc/httpd/conf.d/ssl_rewrite.conf
      if [ "${USE_HTTPS,,}" == "true" ]; then
        echo "Configure SSL rewrite"
        cp .ebextensions/files/ssl_rewrite.conf $outfile
        chmod 644 $outfile
        chown root:root $outfile
      else
        [ -f $outfile ] && rm $outfile
        echo "Do not use SSL"
        exit 0
      fi

container_commands:
  01_https_setup:
    command: "/home/ec2-user/https_setup.sh"

Tenga en cuenta que si cambia USE_HTTPS, debe volver a implementar su aplicación para que el cambio surta efecto. También puede eliminar los echocomandos del https.configarchivo si lo desea.

AWS también tiene alguna documentación sobre esto.

Si está utilizando un balanceador de carga de aplicaciones, agregue el archivo http-to-https.configa su .ebextensionscarpeta y luego agregue la siguiente configuración ( no olvide ingresar el ARN de su certificado https ):

NOTA: asegúrese de que aún no ha agregado un oyente en el puerto 443 a través de la consola EB. Si lo hizo, elimine el oyente antes de agregar el archivo .config.

Resources:
  AWSEBV2LoadBalancerListener:
    Type: 'AWS::ElasticLoadBalancingV2::Listener'
    Properties:
      DefaultActions:
        - Type: redirect
          RedirectConfig:
            Protocol: HTTPS
            Port: '443'
            Host: '#{host}'
            Path: '/#{path}'
            Query: '#{query}'
            StatusCode: HTTP_301
      LoadBalancerArn:
        Ref: AWSEBV2LoadBalancer
      Port: 80
      Protocol: HTTP
  AWSEBV2LoadBalancerListenerHTTPS:
    Type: 'AWS::ElasticLoadBalancingV2::Listener'
    Properties:
      Certificates:
        - CertificateArn: Replace with Certificate ARN
      DefaultActions:
        - Type: forward
          TargetGroupArn:
            Ref: AWSEBV2LoadBalancerTargetGroup
      LoadBalancerArn:
        Ref: AWSEBV2LoadBalancer
      Port: 443
      Protocol: HTTPS 

La ventaja de usar su LB para esto es que su configuración será independiente del servidor que usa como nginx, apache, etc.

Encontré una respuesta de aquí para ser útil.

Todo lo que hice fue hacer la ruta de verificación /index.phpde estado /en lugar de en el proceso predeterminado del balanceador de carga de la aplicación.

¿Por qué no simplemente pone un archivo .htaccess en la carpeta raíz? De esa manera, simplemente puede probarlo y depurarlo. Y si lo incluye en el .zip, se implementará automáticamente en todas las instancias nuevamente.

Simplemente use .htaccess:

RewriteEngine on
RewriteCond %{HTTP:X-Forwarded-Proto} !https
RewriteRule (.*) https://%{HTTP_HOST}%{REQUEST_URI} [R,L]

Tenga en cuenta que la respuesta más votada es un poco antigua ahora. La respuesta de A Paul es en realidad la respuesta correcta. El enlace proporcionado en su respuesta es de AWS (por lo que es el método recomendado para anular su configuración de Apache para realizar la redirección de HTTP a HTTPS cuando ejecuta su aplicación en Elastic Beanstalk).

Hay una cosa muy importante a tener en cuenta. Si está implementando más de una aplicación web, agregar la carpeta .ebextensions dentro de una de sus aplicaciones web no funcionará. Notará que ninguna de las configuraciones que especificó se están escribiendo o creando. Si está implementando varias aplicaciones web en el entorno de Elastic Beanstalk, deberá leer este artículo de AWS Java Tomcat Implementar varios archivos WAR en Elastic Beanstalk

En general, deberá tener la siguiente estructura antes de ejecutar el comando eb para implementar los archivos WAR:

MyApplication.zip
├── .ebextensions
├── foo.war
├── bar.war
└── ROOT.war

Si la carpeta .ebextentions existe dentro de cada archivo WAR, notará que se ignora por completo y no se realizarán cambios de configuración.

Espero que esto ayude a alguien más.

Lo hemos resuelto en nuestro backend manejándolo X-Forwarded-Protocorrectamente.

Esta es nuestra configuración de Grails, pero te ayudará con la idea:

    grails.plugin.springsecurity.secureChannel.useHeaderCheckChannelSecurity = true
    grails.plugin.springsecurity.portMapper.httpPort = 80
    grails.plugin.springsecurity.portMapper.httpsPort = 443
    grails.plugin.springsecurity.secureChannel.secureHeaderName = 'X-Forwarded-Proto'
    grails.plugin.springsecurity.secureChannel.secureHeaderValue = 'http'
    grails.plugin.springsecurity.secureChannel.insecureHeaderName = 'X-Forwarded-Proto'
    grails.plugin.springsecurity.secureChannel.insecureHeaderValue = 'https'
    grails.plugin.springsecurity.secureChannel.definition = [
        [pattern: '/**', access: 'REQUIRES_SECURE_CHANNEL']
    ]

Para ampliar otras dos respuestas a esta pregunta https://stackoverflow.com/a/43026082/8775205 , https://stackoverflow.com/a/42035023/8775205 . Para los usuarios de Spring Boot que implementan sus servicios en AWS con ELB y necesitan una guía paso a paso, pueden agregar un archivo ****. Conf en src / main / webapp / .ebextensions / httpd / conf.d / en su proyecto. .

src
--main
----java
----resources
----webapps
------.ebextensions
--------httpd
----------confd
------------****.conf

****. conf se parece a lo siguiente. Noté que tengo mi sitio de prueba con una sola instancia, por lo que agrego una condición para excluirlo.

<VirtualHost *:80>
   LoadModule rewrite_module modules/mod_rewrite.so

   RewriteEngine On
   RewriteCond %{HTTP:X-Forwarded-Proto} !https
   RewriteCond %{HTTP_USER_AGENT} !ELB-HealthChecker 
   RewriteCond %{HTTP_HOST} !testexample.com #excludes test site
   RewriteRule (.*) https://%{HTTP_HOST}%{REQUEST_URI}

   <Proxy *>
     Order deny,allow
     Allow from all
   </Proxy>

   ProxyPass / http://localhost:8080/ retry=0
   ProxyPassReverse / http://localhost:8080/
   ProxyPreserveHost on

   ErrorLog /var/log/httpd/elasticbeanstalk-error_log

</VirtualHost>

Después de esto, recuerde agregar un "recurso" en maven-war-plugin en su pom.xml para recoger la configuración anterior.

<plugin>
     <groupId>org.apache.maven.plugins</groupId>  
     <artifactId>maven-war-plugin</artifactId>  
     <configuration>  
         <webResources>
             <resource>  
               <!-- some other resource configured by yourself-->
             </resource> 
             <resource>
                <directory>src/main/webapps/.ebextensions</directory>
                 <targetPath>.ebextensions</targetPath>
                 <filtering>true</filtering>
             </resource> 
         </webResources>  
     </configuration>  
     <version>2.1.1</version>
 </plugin>

Finalmente, confirme y envíe su código, espere a que AWS codebuild y codepipeline recoja su código de su repositorio y lo implemente en el entorno beanstalk, o simplemente empaque su proyecto en un archivo war y cárguelo en su entorno beanstalk de AWS

AWS no acepta unserscores (_) en los encabezados, mientras que podemos usar (-), así que elimine los guiones bajos de las variables del encabezado, ejemplo: - header_var_val = "algún valor" reemplácelo con headervarval = "algún valor" . Esto funciona para mi.

Si utiliza un entorno de carga equilibrada, puede seguir las instrucciones para configurar HTTPS para su entorno de AWS Elastic Beanstalk y, al final, deshabilitar el puerto HTTP.

Tenga en cuenta que actualmente el capa de uso gratuito de AWS incluye la misma cantidad de horas para un Elastic Load Balancing (ELB) que para una microinstancia EC2.

esta es una solución fácil

1. ssh en su instancia EC2
2. copie el contenido de /etc/httpd/conf.d/wsgi.conf en un archivo local llamado wsgi.conf que se colocará en la carpeta base de su aplicación

3. Edite la versión local de wsgi.conf y agregue las siguientes reglas de redireccionamiento dentro de las etiquetas <VirtualHost> </ VirtualHost>

   RewriteEngine On
   RewriteCond %{HTTP:X-Forwarded-Proto} !https
   RewriteRule !/status https://%{SERVER_NAME}%{REQUEST_URI} [L,R=301]
   

4. Cambie el "/ estado" a cualquier página que esté utilizando como página de verificación de estado .

5. Guarda el archivo

6. Edite su archivo <app> .conf dentro de su.  directorio ebextensions para agregar un comando de contenedor para copiar esta versión de wsgi.conf sobre la versión de Amazon

   container_commands:
   01_syncdb:
     command: "django-admin.py syncdb --noinput" leader_only: true
   02_collectstatic:
     command: "django-admin.py collectstatic --noinput"
   03_wsgireplace:
     command: 'cp wsgi.conf ../wsgi.conf'
   ...
   

7. Implementa el código.

8. La versión implementada de wsg.conf en /etc/httd/conf.d/wsgi.conf ahora incluirá las reglas de redireccionamiento necesarias.

Debería funcionar y el archivo se actualizará correctamente para cada implementación. Lo único que hay que tener en cuenta es que si Amazon cambia el contenido del archivo wsgi.conf base en el futuro, es posible que su copia ya no funcione.

Autor rickchristianson