Wie verwenden wir Verschlüsseln mit Docker-container auf der Grundlage der Node.js Bild

Das erste, was ich getan habe ist, erstellen Sie eine einfache express-basierte docker-image.

Ich bin mit dem folgenden app.js aus express-s Hallo Welt " - Beispiel in Ihre docs:

var express = require('express');
var app = express();

app.get('/', function (req, res) {
  res.send('Hello World!');
});

app.listen(3000, function () {
  console.log('Example app listening on port 3000!');
});

Ich auch am Ende mit den folgenden packages.json Datei nach dem ausführen Ihrer npm init im gleichen doc:

{
  "name": "exampleexpress",
  "version": "1.0.0",
  "description": "",
  "main": "app.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "express": "^4.14.0"
  }
}

Habe ich die folgenden Dockerfile:

FROM node:onbuild
EXPOSE 3000
CMD node app.js

Hier ist die Ausgabe, wenn ich meine docker build Schritt. Ich habe entfernt die meisten der npm install Ausgang für die Kürze Willen:

$ docker build -t exampleexpress .
Sending build context to Docker daemon 1.262 MB
Step 1 : FROM node:onbuild
# Executing 3 build triggers...
Step 1 : COPY package.json /usr/src/app/
Step 1 : RUN npm install
 ---> Running in 981ca7cb7256
npm info it worked if it ends with ok
<snip>
npm info ok
Step 1 : COPY . /usr/src/app
 ---> cf82ea76e369
Removing intermediate container ccd3f79f8de3
Removing intermediate container 391d27f33348
Removing intermediate container 1c4feaccd08e
Step 2 : EXPOSE 3000
 ---> Running in 408ac1c8bbd8
 ---> c65c7e1bdb94
Removing intermediate container 408ac1c8bbd8
Step 3 : CMD node app.js
 ---> Running in f882a3a126b0
 ---> 5f0f03885df0
Removing intermediate container f882a3a126b0
Successfully built 5f0f03885df0

Ausführen dieses Bild funktioniert wie folgt:

$ docker run -d --name helloworld -p 3000:3000 exampleexpress
$ curl 127.0.0.1:3000
Hello World!

Wir reinigen können dies durch tun: docker rm -f helloworld

Nun, ich habe meine sehr basic-express-basierte website läuft in einem Docker-container, aber es haben noch nicht alle TLS einrichten. Wenn Sie wieder die expressjs-docs, die security-best practice bei der Verwendung von TLS ist die Verwendung von nginx.

Da möchte ich Euch eine neue Komponente (nginx), das mache ich mit einem zweiten container.

Da nginx müssen einige Zertifikate, mit zu arbeiten, lassen Sie uns gehen Sie vor und erzeugen, die mit der letsencrypt client. Die letsencrypt docs, wie letsencrypt im Andockfenster finden Sie hier: http://letsencrypt.readthedocs.io/en/latest/using.html#running-with-docker

Führen Sie die folgenden Befehle ein, um die Initiale Erstellung der Zertifikate. Sie müssen führen Sie diese auf einem system, das sich an das öffentliche internet angeschlossen, und über port 80/443 erreichbar von der letsencrypt-Server. Sie müssen auch über Ihren DNS-Namen einrichten und zeigte auf das Feld, das Sie führen dies auf:

export LETSENCRYPT_EMAIL=<youremailaddress>
export DNSNAME=www.example.com

docker run --rm \
    -p 443:443 -p 80:80 --name letsencrypt \
    -v "/etc/letsencrypt:/etc/letsencrypt" \
    -v "/var/lib/letsencrypt:/var/lib/letsencrypt" \
    quay.io/letsencrypt/letsencrypt:latest \
    certonly -n -m $LETSENCRYPT_EMAIL -d $DNSNAME --standalone --agree-tos

Stellen Sie sicher, ersetzen Sie die Werte für LETSENCRYPT_EMAIL und DNSNAME. Die E-Mail-Adresse wird verwendet für Ablauf-Benachrichtigungen.

Nun, lassen Sie uns einen nginx-server, wird das neu generierte Zertifikat. Zuerst brauchen wir eine nginx-config-Datei, die konfiguriert ist für TLS:

user  nginx;
worker_processes  1;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;


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"';

    access_log  /dev/stdout  main;
    sendfile        on;
    keepalive_timeout  65;

    server {
        listen       80;
        server_name  _;
        return 301 https://$host$request_uri;
    }

    server {
        listen              443 ssl;
        #add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
        server_name         www.example.com;
        ssl_certificate     /etc/letsencrypt/live/www.example.com/fullchain.pem;
        ssl_certificate_key /etc/letsencrypt/live/www.example.com/privkey.pem;
        ssl_protocols       TLSv1 TLSv1.1 TLSv1.2;
        ssl_ciphers         HIGH:!aNULL:!MD5;

        location ^~ /.well-known/ {
            root   /usr/share/nginx/html;
            allow all;
        }

        location / {
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_pass http://expresshelloworld:3000;
        }
    }
}

Können wir in dieser config-Datei in unserem eigenen nginx-image mit dem folgenden Dockerfile:

FROM nginx:alpine
COPY nginx.conf /etc/nginx/nginx.conf

Diese aufbauen kann mit dem folgenden Befehl: docker build -t expressnginx .

Als Nächstes erstellen wir eine benutzerdefinierte Netzwerk-so können wir nutzen, Docker ' s service-discovery-Funktion:

docker network create -d bridge expressnet

Nun können wir das Feuer bis auf die helloworld-und nginx-Container:

docker run -d \
    --name expresshelloworld --net expressnet exampleexpress
docker run -d -p 80:80 -p 443:443 \
    --name expressnginx --net expressnet \
    -v /etc/letsencrypt:/etc/letsencrypt \
    -v /usr/share/nginx/html:/usr/share/nginx/html \
    expressnginx

Überprüfen Sie, dass nginx kam ordnungsgemäß, indem Sie einen Blick auf die Ausgabe von docker logs expressnginx.

Die nginx-config-Datei sollte Umleitung alle Anfragen auf port 80 über port 443. Wir können testen, ob Sie durch ausführen der folgenden:

curl -v http://www.example.com/

Sollten wir auch, an diesem Punkt, in der Lage sein, um einen erfolgreichen TLS-Verbindung, und sehen unsere Hello World! Antwort zurück:

curl -v https://www.example.com/

Nun, um die Verlängerung. Die nginx.conf oben genannten Bestimmungen für die letsencrypt .bekannten Pfad zum webroot überprüfungsmethode. Wenn Sie führen Sie den folgenden Befehl, es handle Erneuerung. Normalerweise werden Sie diesen Befehl ausführen, auf eine Art cron so, dass Ihre Zertifikate erneuert werden, bevor Sie verfallen:

export LETSENCRYPT_EMAIL=me@example.com
export DNSNAME=www.example.com

docker run --rm --name letsencrypt \
    -v "/etc/letsencrypt:/etc/letsencrypt" \
    -v "/var/lib/letsencrypt:/var/lib/letsencrypt" \
    -v "/usr/share/nginx/html:/usr/share/nginx/html" \
    quay.io/letsencrypt/letsencrypt:latest \
    certonly -n --webroot -w /usr/share/nginx/html -d $DNSNAME --agree-tos

Habe ich vor kurzem implementiert https mit let ' s encrypt mithilfe von nginx. Ich bin die Auflistung der Herausforderungen, die ich konfrontiert haben, und die Art und Weise habe ich umgesetzt-Schritt für Schritt hier.

Herausforderung:

1. Docker-Dateisystem ist vergänglich. Das bedeutet, dass jedes mal, nachdem Sie ein build der Zertifikate gespeichert sind, oder wenn Sie erzeugt im inneren des Containers verschwinden. Es ist also sehr schwierig zu generieren, Zertifikate in den container.

Schritte, Sie zu überwinden:

Unten guide ist unabhängig der Art der app, die Sie haben, als es nur um die nginx und docker.

• Ersten Installation von nginx auf Ihrem server (nicht container, sondern direkt auf dem server.) Sie können Folgen Sie dieser Anleitung zu generieren-Zertifikat für Ihre domain mit certbot.

• Nun aufhören, diese nginx server und starten Sie den Aufbau Ihrer app. Installieren Sie nginx auf Ihrem Behälter und öffnen Sie den port 80, 443 auf Ihrem docker-container. (wenn sich die Verwendung von aws öffnen Sie auf der ec2-Instanz auch als standardmäßig aws öffnen, nur port 80)

• Nächsten Lauf Ihre container und mount der volumes, die Zertifikat-Datei direkt auf dem Behälter. Ich habe geantwortet hier eine Frage, wie das gleiche zu tun.

• Damit wird https auf Ihre app. Incase Sie sind nicht in der Lage zu beobachten, und sind mit chrome versuchen clearing dns cache für chrome

Auto-Erneuerung :

• Let ' s encrypt-Zertifikate sind nur gültig für 3 Monate. In der obigen Anleitung Schritte zum konfigurieren von auto-Erneuerung ist auch das setup. Aber Sie haben zu stoppen und starten Sie Ihren container alle 3 Monate mindestens, um sicherzustellen, dass die Zertifikate montiert auf dem docker-container sind bis zu Datum. (Sie müssen neu starten, den nginx server setzen wir im ersten Schritt zu machen, der Erneuerung geschehen reibungslos)

Front-end - - NGINX - die listening-port 443, und Proxys zu beck Ende

Back-end - Sie docker-container