fragen stichworte

Elastische Bohnenstange zwingt https

Ich habe Probleme, HTTPS mit einer Site zu erzwingen, die ich über AWS Elastic Beanstalk bereitstelle.

Es ist eine Frontend-Anwendung, die EmberJS verwendet. Ich bin seit vielen Tagen in Kreisen unterwegs und habe versucht herauszufinden, wie der HTTP-Verkehr auf https umgeleitet werden kann. Ich verwende Amazon Linux AMI auf meiner EC2-Maschine.

Ich bin zu dem Schluss gekommen (immer noch nicht sicher, ob dies richtig ist), dass es nicht in Elastic Beanstalk liegt, dass ich HTTPS erzwinge. Ich erlaube sowohl HTTP als auch HTTPS über meinen Elastic Beanstalk Load Balancer und versuche, auf dem Server umzuleiten.

Hier stoße ich auf Probleme. Ich finde viele Antworten zu Umschreibungsregeln ohne mod_rewrite, die auf dem X-Forwarded-Proto -Header basieren, aber diese Datei ist auf meiner EC2-Maschine gemäß einer Suchsuche nicht vorhanden.

Ich habe auch versucht, eine Konfigurationsdatei im Verzeichnis .ebextensions zu erstellen, aber das hat auch nicht funktioniert.

Die Hauptsache, die ich zu tun versuche, ist, dass Benutzer zu https geleitet werden, wenn versucht wird, die http-Adresse zu treffen. Alle Hinweise oder Vorschläge sind dankbar!

EDIT: Ich verwende 64bit Debian jessie v1.4.1, auf dem Python 3.4 (vorkonfiguriert - Docker) ausgeführt wird

antworten

Es ist auch möglich, dies etwas einfacher zu tun, ohne den Load Balancer zu berühren, indem Sie den Header X-Forwarded-Proto von ELB verwenden. Hier ist, was ich getan habe:

files:
  "/etc/nginx/sites-available/elasticbeanstalk-nginx-docker-proxy.conf":
    mode: "00644"
    owner: root
    group: root
    content: |
      map $http_upgrade $connection_upgrade {
        default        "upgrade";
        ""            "";
      }

      server {
        listen 80;

        gzip on;
        gzip_comp_level 4;
        gzip_types text/html text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript;

        access_log/var/log/nginx/access.log;

        location/{
          proxy_pass            http://docker;
          proxy_http_version    1.1;

          proxy_set_header      Connection      $connection_upgrade;
          proxy_set_header      Upgrade         $http_upgrade;
          proxy_set_header      Host            $host;
          proxy_set_header      X-Real-IP       $remote_addr;
          proxy_set_header      X-Forwarded-For $proxy_add_x_forwarded_for;
        }

        if ($http_x_forwarded_proto = 'http') {
          return 301 https://$host$request_uri;
        }
      }

Ich denke, Sie müssen angeben, welche Elastic Beanstalk-Umgebung Sie verwenden (siehe: Unterstützte Plattformen), da die Umgebung anders konfiguriert ist.

Grundsätzlich müssen Sie Folgendes anpassen:

  • Elastic Load Balancer:
    • Hören Sie Port 80 ab und übergeben Sie ihn an Port 80 der EC2-Instanz.
    • Hören Sie Port 443 ab und übergeben Sie ihn an den Port 443 der EC2-Instanz.
  • EC2-Webserver/Proxy:
    • Hören Sie sich Port 80 an und antworten Sie mit einer Weiterleitung an HTTPS.
    • Hören Sie sich Port 443 an und übergeben Sie die Anforderung.

Zum Anpassen können Sie CLI oder .ebextensions verwenden.

Sie können die Option Aktivieren von HTTPS und HTTP-Redirect für AWS Elastic Beanstalk aktivieren. Hier erfahren Sie, wie Sie einen einzelnen Docker-Container für den elastischen Beanstalk für HTTPS und HTTP (Weiterleitung zu HTTPS) konfigurieren. Sie können die Konfiguration nach Bedarf anpassen.

Elastic Beanstalk unterstützt nicht mehrere Ports eines einzelnen Docker-Containers. Daher müssen Sie dies auf der Proxy-Ebene wie vorgeschlagen behandeln. Ihre EC2-Instanz muss jedoch nicht über Ihr Zertifikat Bescheid wissen, da Sie die SSL-Verbindung am Load Balancer beenden können.

Erstellen Sie im Verzeichnis .ebextensions eine Konfiguration für den Nginx-Proxy, die zwei Serverkonfigurationen enthält. eine, die http://docker (die Standardkonfiguration, Port 80) und eine, die zu https umleitet (ich wählte Port 8080).

.ebextensions/01-nginx-proxy.config:

files:
  "/etc/nginx/sites-available/000-default.conf":
    mode: "000644"
    owner: root
    group: root
    content: |
      map $http_upgrade $connection_upgrade {
          default        "upgrade";
          ""            "";
      }

      server {
          listen 80;

          gzip on;
          gzip_comp_level 4;
          gzip_types text/html text/plain text/css application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript;

          access_log   /var/log/nginx/access.log;

          location/{
              proxy_pass            http://docker;
              proxy_http_version    1.1;

              proxy_set_header    Connection            $connection_upgrade;
              proxy_set_header    Upgrade                $http_upgrade;
              proxy_set_header    Host                $host;
              proxy_set_header    X-Real-IP            $remote_addr;
              proxy_set_header    X-Forwarded-For        $proxy_add_x_forwarded_for;
          }
      }

      server {
          listen 8080;

          location/{
              return 301 https://$host$request_uri;
          }
      }

commands:
   00_enable_site:
    command: 'rm -f/etc/nginx/sites-enabled/* && ln -s/etc/nginx/sites-available/000-default.conf/etc/nginx/sites-enabled/000-default.conf'

Erstellen Sie eine zweite Konfiguration für die EB-Lastausgleichs- und Sicherheitsgruppen, die diese wie folgt einrichtet:

  • EC2-Instanz:
    • Zulassen des Datenverkehrs auf den Ports 80/8080 vom Load Balancer
    • Zulassen des Datenverkehrs an Port 22 von überall (für SSH-Zugriff, optional)
  • Load Balancer:
    • Leiten Sie Port 443 HTTPS an Port 80 HTTP
    • weiter
    • Weiterleiten von Port 80 HTTP an Port 8080 HTTP

.ebextensions/02-load-balancer.config:

"Resources" : {
  "AWSEBSecurityGroup": {
    "Type" : "AWS::EC2::SecurityGroup",
    "Properties" : {
      "GroupDescription" : "Instance security group (22/80/8080 in)",
      "SecurityGroupIngress" : [ {
          "IpProtocol" : "tcp",
          "FromPort" : "80",
          "ToPort" : "80",
          "SourceSecurityGroupId" : { "Ref" : "AWSEBLoadBalancerSecurityGroup" }
        }, {
          "IpProtocol" : "tcp",
          "FromPort" : "8080",
          "ToPort" : "8080",
          "SourceSecurityGroupId" : { "Ref" : "AWSEBLoadBalancerSecurityGroup" }
        }, {
          "IpProtocol" : "tcp",
          "FromPort" : "22",
          "ToPort" : "22",
          "CidrIp" : "0.0.0.0/0"
        } ]
    }
  },
  "AWSEBLoadBalancerSecurityGroup": {
    "Type" : "AWS::EC2::SecurityGroup",
    "Properties" : {
      "GroupDescription" : "Load balancer security group (80/443 in, 80/8080 out)",
      "VpcId" : "<vpc_id>",
      "SecurityGroupIngress" : [ {
          "IpProtocol" : "tcp",
          "FromPort" : "80",
          "ToPort" : "80",
          "CidrIp" : "0.0.0.0/0"
        }, {
          "IpProtocol" : "tcp",
          "FromPort" : "443",
          "ToPort" : "443",
          "CidrIp" : "0.0.0.0/0"
        } ],
      "SecurityGroupEgress": [ {
          "IpProtocol" : "tcp",
          "FromPort" : "80",
          "ToPort" : "80",
          "CidrIp" : "0.0.0.0/0"
        }, {
          "IpProtocol" : "tcp",
          "FromPort" : "8080",
          "ToPort" : "8080",
          "CidrIp" : "0.0.0.0/0"
        } ]
    }
  },
  "AWSEBLoadBalancer" : {
    "Type" : "AWS::ElasticLoadBalancing::LoadBalancer",
    "Properties" : {
      "Listeners" : [ {
          "LoadBalancerPort" : "80",
          "InstancePort" : "8080",
          "Protocol" : "HTTP"
        }, {
          "LoadBalancerPort" : "443",
          "InstancePort" : "80",
          "Protocol" : "HTTPS",
          "SSLCertificateId" : "arn:aws:iam::<certificate_id>:<certificate_path>"
        } ]
    }
  }
}

(Hinweis: Vergessen Sie nicht, SSLCertificateId und VpcId durch Ihre Werte zu ersetzen).

Jeglicher Datenverkehr auf Port 80 des Load Balancer (HTTP) trifft auf Port 8080 in der EC2-Instanz, der zu HTTPS umleitet. Der Datenverkehr auf Port 443 auf dem Load Balancer (HTTPS) wird von Port 80 in der EC2-Instanz bedient, bei der es sich um den Docker-Proxy handelt.