Dela via

Aktivera en TLS-slutpunkt i en sidovagnscontainer

  • Artikel

Den här artikeln visar hur du skapar en containergrupp med en programcontainer och en sidovagnscontainer som kör en TLS/SSL-provider. Genom att konfigurera en containergrupp med en separat TLS-slutpunkt aktiverar du TLS-anslutningar för ditt program utan att ändra programkoden.

Du konfigurerar en exempelcontainergrupp som består av två containrar:

I det här exemplet exponerar containergruppen endast port 443 för Nginx med sin offentliga IP-adress. Nginx dirigerar HTTPS-begäranden till den tillhörande webbappen, som lyssnar internt på port 80. Du kan anpassa exemplet för containerprogram som lyssnar på andra portar.

Se Nästa steg för andra metoder för att aktivera TLS i en containergrupp.

Förutsättningar

  • Den här artikeln kräver version 2.0.55 eller senare av Azure CLI. Om du använder Azure Cloud Shell är den senaste versionen redan installerad.

Skapa ett självsignerat certifikat

Om du vill konfigurera Nginx som TLS-provider behöver du ett TLS/SSL-certifikat. Den här artikeln visar hur du skapar och konfigurerar ett självsignerat TLS/SSL-certifikat. För produktionsscenarier bör du hämta ett certifikat från en certifikatutfärdare.

Om du vill skapa ett självsignerat TLS/SSL-certifikat använder du OpenSSL-verktyget som är tillgängligt i Azure Cloud Shell och många Linux-distributioner, eller använder ett jämförbart klientverktyg i ditt operativsystem.

Skapa först en certifikatbegäran (.csr-fil) i en lokal arbetskatalog:

openssl req -new -newkey rsa:2048 -nodes -keyout ssl.key -out ssl.csr

Följ anvisningarna för att lägga till identifieringsinformationen. För Eget namn anger du det värdnamn som är associerat med certifikatet. När du uppmanas att ange ett lösenord trycker du på Retur utan att skriva för att hoppa över att lägga till ett lösenord.

Kör följande kommando för att skapa det självsignerade certifikatet (.crt-filen) från certifikatbegäran. Exempel:

openssl x509 -req -days 365 -in ssl.csr -signkey ssl.key -out ssl.crt

Nu bör du se tre filer i katalogen: certifikatbegäran (ssl.csr), den privata nyckeln (ssl.key) och det självsignerade certifikatet (ssl.crt). Du använder ssl.key och ssl.crt i senare steg.

Konfigurera Nginx att använda TLS

Skapa Nginx-konfigurationsfil

I det här avsnittet skapar du en konfigurationsfil för Nginx som ska använda TLS. Börja med att kopiera följande text till en ny fil med namnet nginx.conf. I Azure Cloud Shell kan du använda Visual Studio Code för att skapa filen i arbetskatalogen:

code nginx.conf

I locationanger du proxy_pass med rätt port för din app. I det här exemplet anger vi port 80 för containern aci-helloworld .

# nginx Configuration File
# https://wiki.nginx.org/Configuration

# Run as a less privileged user for security reasons.
user nginx;

worker_processes auto;

events {
  worker_connections 1024;
}

pid        /var/run/nginx.pid;

http {

    #Redirect to https, using 307 instead of 301 to preserve post data

    server {
        listen [::]:443 ssl;
        listen 443 ssl;

        server_name localhost;

        # Protect against the BEAST attack by not using SSLv3 at all. If you need to support older browsers (IE6) you may need to add
        # SSLv3 to the list of protocols below.
        ssl_protocols              TLSv1.2;

        # Ciphers set to best allow protection from Beast, while providing forwarding secrecy, as defined by Mozilla - https://wiki.mozilla.org/Security/Server_Side_TLS#Nginx
        ssl_ciphers                ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:ECDHE-RSA-RC4-SHA:ECDHE-ECDSA-RC4-SHA:AES128:AES256:RC4-SHA:HIGH:!aNULL:!eNULL:!EXPORT:!DES:!3DES:!MD5:!PSK;
        ssl_prefer_server_ciphers  on;

        # Optimize TLS/SSL by caching session parameters for 10 minutes. This cuts down on the number of expensive TLS/SSL handshakes.
        # The handshake is the most CPU-intensive operation, and by default it is re-negotiated on every new/parallel connection.
        # By enabling a cache (of type "shared between all Nginx workers"), we tell the client to re-use the already negotiated state.
        # Further optimization can be achieved by raising keepalive_timeout, but that shouldn't be done unless you serve primarily HTTPS.
        ssl_session_cache    shared:SSL:10m; # a 1mb cache can hold about 4000 sessions, so we can hold 40000 sessions
        ssl_session_timeout  24h;


        # Use a higher keepalive timeout to reduce the need for repeated handshakes
        keepalive_timeout 300; # up from 75 secs default

        # remember the certificate for a year and automatically connect to HTTPS
        add_header Strict-Transport-Security 'max-age=31536000; includeSubDomains';

        ssl_certificate      /etc/nginx/ssl.crt;
        ssl_certificate_key  /etc/nginx/ssl.key;

        location / {
            proxy_pass http://localhost:80; # TODO: replace port if app listens on port other than 80

            proxy_set_header Connection "";
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $remote_addr;
        }
    }
}

Base64-koda hemligheter och konfigurationsfil

Base64-koda Nginx-konfigurationsfilen, TLS/SSL-certifikatet och TLS-nyckeln. I nästa avsnitt anger du det kodade innehållet i en YAML-fil som används för att distribuera containergruppen.

cat nginx.conf | base64 > base64-nginx.conf
cat ssl.crt | base64 > base64-ssl.crt
cat ssl.key | base64 > base64-ssl.key

Distribuera containergrupp

Distribuera nu containergruppen genom att ange containerkonfigurationerna i en YAML-fil.

Skapa YAML-fil

Kopiera följande YAML till en ny fil med namnet deploy-aci.yaml. I Azure Cloud Shell kan du använda Visual Studio Code för att skapa filen i arbetskatalogen:

code deploy-aci.yaml

Ange innehållet i de base64-kodade filerna som anges under secret. Till exempel cat var och en av de base64-kodade filerna för att se dess innehåll. Under distributionen läggs dessa filer till på en hemlig volym i containergruppen. I det här exemplet monteras den hemliga volymen på Nginx-containern.

api-version: 2019-12-01
location: westus
name: app-with-ssl
properties:
  containers:
  - name: nginx-with-ssl
    properties:
      image: mcr.microsoft.com/oss/nginx/nginx:1.15.5-alpine
      ports:
      - port: 443
        protocol: TCP
      resources:
        requests:
          cpu: 1.0
          memoryInGB: 1.5
      volumeMounts:
      - name: nginx-config
        mountPath: /etc/nginx
  - name: my-app
    properties:
      image: mcr.microsoft.com/azuredocs/aci-helloworld
      ports:
      - port: 80
        protocol: TCP
      resources:
        requests:
          cpu: 1.0
          memoryInGB: 1.5
  volumes:
  - secret:
      ssl.crt: <Enter contents of base64-ssl.crt here>
      ssl.key: <Enter contents of base64-ssl.key here>
      nginx.conf: <Enter contents of base64-nginx.conf here>
    name: nginx-config
  ipAddress:
    ports:
    - port: 443
      protocol: TCP
    type: Public
  osType: Linux
tags: null
type: Microsoft.ContainerInstance/containerGroups

Distribuera containergruppen

Skapa en resursgrupp med kommandot az group create :

az group create --name myResourceGroup --location westus

Distribuera containergruppen med kommandot az container create och skicka YAML-filen som ett argument.

az container create --resource-group <myResourceGroup> --file deploy-aci.yaml

Visa distributionstillstånd

Om du vill visa tillståndet för distributionen använder du följande az container show-kommando :

az container show --resource-group <myResourceGroup> --name app-with-ssl --output table

För en lyckad distribution liknar utdata följande:

Name          ResourceGroup    Status    Image                                                    IP:ports             Network    CPU/Memory       OsType    Location
------------  ---------------  --------  -------------------------------------------------------  -------------------  ---------  ---------------  --------  ----------
app-with-ssl  myresourcegroup  Running   nginx, mcr.microsoft.com/azuredocs/aci-helloworld        52.157.22.76:443     Public     1.0 core/1.5 gb  Linux     westus

Verifiera TLS-anslutningen

Använd webbläsaren för att navigera till containergruppens offentliga IP-adress. IP-adressen som visas i det här exemplet är 52.157.22.76, så URL:en är https://52.157.22.76. Du måste använda HTTPS för att se programmet som körs på grund av Nginx-serverkonfigurationen. Försök att ansluta via HTTP misslyckas.

Skärmbild från webbläsaren som visar ett program som körs i en instans av Azure-containern

Anteckning

Eftersom det här exemplet använder ett självsignerat certifikat och inte ett från en certifikatutfärdare, visar webbläsaren en säkerhetsvarning när du ansluter till webbplatsen via HTTPS. Du kan behöva acceptera varningen eller justera inställningarna för webbläsare eller certifikat för att gå vidare till sidan. Det här beteendet är förväntat.

Nästa steg

Den här artikeln visade hur du konfigurerar en Nginx-container för att aktivera TLS-anslutningar till en webbapp som körs i containergruppen. Du kan anpassa det här exemplet för appar som lyssnar på andra portar än port 80. Du kan också uppdatera Nginx-konfigurationsfilen för att automatiskt omdirigera serveranslutningar på port 80 (HTTP) för att använda HTTPS.

Även om den här artikeln använder Nginx i sidovagnen kan du använda en annan TLS-provider, till exempel Caddy.

Om du distribuerar din containergrupp i ett virtuellt Azure-nätverk kan du överväga andra alternativ för att aktivera en TLS-slutpunkt för en instans av en serverdelscontainer, inklusive: