Skapa en inkommande styrenhet för HTTPS och använd dina egna TLS-certifikat på Azure Kubernetes Service (AKS)

  • Artikel
  • 9 minuter för att läsa

En ingress-kontrollant är en del av programvaran som tillhandahåller omvänd proxy, konfigurerbar trafikroutning och TLS-Avslut för Kubernetes-tjänster. Kubernetes ingress-resurser används för att konfigurera inkommande regler och vägar för enskilda Kubernetes-tjänster. Med hjälp av en ingress-kontrollant och ingress-regler kan en IP-adress användas för att dirigera trafik till flera tjänster i ett Kubernetes-kluster.

Den här artikeln visar hur du distribuerar NGINX-ingresskontrollanten i ett Azure Kubernetes Service-kluster (AKS). Du genererar dina egna certifikat och skapar en Kubernetes-hemlighet för användning med ingressvägen. Slutligen körs två program i AKS-klustret, som var och en kan nås via en enda IP-adress.

Du kan även:

Innan du börjar

Den här artikeln använder Helm 3 för att installera NGINX-indatakontrollanten på en [version av Kubernetes som stöds][aks-stödda versioner]. Kontrollera att du använder den senaste versionen av Helm och har åtkomst till Helm-lagringsplatsen ingress-nginx. Stegen som beskrivs i den här artikeln kanske inte är kompatibla med tidigare versioner av Helm-diagrammet, NGINX-indatakontrollanten eller Kubernetes.

Mer information om hur du konfigurerar och använder Helm finns i Installera program med Helm i Azure Kubernetes Service (AKS).

Den här artikeln kräver också att du kör Azure CLI version 2.0.64 eller senare. Kör az --version för att hitta versionen. Om du behöver installera eller uppgradera kan du läsa Installera Azure CLI.

Dessutom förutsätter den här artikeln att du har ett befintligt AKS-kluster med ett integrerat ACR. Mer information om hur du skapar ett AKS-kluster med ett integrerat ACR finns i Autentisera med Azure Container Registry från Azure Kubernetes Service.

Importera de avbildningar som används av Helm-diagrammet till din ACR

I den här artikeln används Helm-diagrammet för NGINX-inresskontrollanten,som förlitar sig på tre containeravbildningar. Använd az acr import för att importera avbildningarna till ACR.

REGISTRY_NAME=<REGISTRY_NAME>
SOURCE_REGISTRY=k8s.gcr.io
CONTROLLER_IMAGE=ingress-nginx/controller
CONTROLLER_TAG=v1.0.4
PATCH_IMAGE=ingress-nginx/kube-webhook-certgen
PATCH_TAG=v1.1.1
DEFAULTBACKEND_IMAGE=defaultbackend-amd64
DEFAULTBACKEND_TAG=1.5

az acr import --name $REGISTRY_NAME --source $SOURCE_REGISTRY/$CONTROLLER_IMAGE:$CONTROLLER_TAG --image $CONTROLLER_IMAGE:$CONTROLLER_TAG
az acr import --name $REGISTRY_NAME --source $SOURCE_REGISTRY/$PATCH_IMAGE:$PATCH_TAG --image $PATCH_IMAGE:$PATCH_TAG
az acr import --name $REGISTRY_NAME --source $SOURCE_REGISTRY/$DEFAULTBACKEND_IMAGE:$DEFAULTBACKEND_TAG --image $DEFAULTBACKEND_IMAGE:$DEFAULTBACKEND_TAG

Anteckning

Förutom att importera containeravbildningar till ACR kan du också importera Helm-diagram till ACR. Mer information finns i Push and pull Helm charts to an Azure container registry (Skicka och hämta Helm-diagram till ett Azure-containerregister).

Skapa en ingress-kontrollant

Om du vill skapa ingress-kontrollanten Helm använder du för att installera nginx-ingress. För ytterligare redundans distribueras två repliker av NGINX-ingresskontrollanterna med parametern --set controller.replicaCount. Om du vill dra full nytta av att köra repliker av ingress-kontrollanten kontrollerar du att det finns fler än en nod i ditt AKS-kluster.

Ingresskontrollanten måste också schemaläggas på en Linux-nod. Windows Server-noder bör inte köra ingresskontrollanten. En nodväljare anges med parametern --set nodeSelector för att instruera Kubernetes-schemaläggaren att köra NGINX-ingresskontrollanten på en Linux-baserad nod.

Tips

I följande exempel skapas ett Kubernetes-namnområde för ingressresurserna med namnet ingress-basic och är avsett att fungera inom det namnområdet. Ange ett namnområde för din egen miljö efter behov. Om ditt AKS-kluster inte är Kubernetes RBAC aktiverat lägger du till --set rbac.create=false i Helm-kommandona.

Tips

Om du vill aktivera bevarande av klientkällans IP-adress för begäranden till containrar i klustret lägger du --set controller.service.externalTrafficPolicy=Local till i installationskommandot för Helm. Klientens käll-IP lagras i begärandehuvudet under X-Forwarded-For. När du använder en ingress-kontrollant med klientkällans IP-bevarande aktiverat fungerar inte TLS-genomgående.

# Add the ingress-nginx repository
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx

# Set variable for ACR location to use for pulling images
ACR_URL=<REGISTRY_URL>

# Use Helm to deploy an NGINX ingress controller
helm install nginx-ingress ingress-nginx/ingress-nginx \
    --namespace ingress-basic --create-namespace \
    --set controller.replicaCount=2 \
    --set controller.nodeSelector."kubernetes\.io/os"=linux \
    --set controller.image.registry=$ACR_URL \
    --set controller.image.image=$CONTROLLER_IMAGE \
    --set controller.image.tag=$CONTROLLER_TAG \
    --set controller.image.digest="" \
    --set controller.admissionWebhooks.patch.nodeSelector."kubernetes\.io/os"=linux \
    --set controller.admissionWebhooks.patch.image.registry=$ACR_URL \
    --set controller.admissionWebhooks.patch.image.image=$PATCH_IMAGE \
    --set controller.admissionWebhooks.patch.image.tag=$PATCH_TAG \
    --set controller.admissionWebhooks.patch.image.digest="" \
    --set defaultBackend.nodeSelector."kubernetes\.io/os"=linux \
    --set defaultBackend.image.registry=$ACR_URL \
    --set defaultBackend.image.image=$DEFAULTBACKEND_IMAGE \
    --set defaultBackend.image.tag=$DEFAULTBACKEND_TAG \
    --set defaultBackend.image.digest=""

Under installationen skapas en offentlig IP-adress i Azure för ingress-kontrollanten. Den här offentliga IP-adressen är statisk för ingress-kontrollantens livslängd. Om du tar bort ingress-kontrollanten går tilldelningen av den offentliga IP-adressen förlorad. Om du sedan skapar ytterligare en ingress-kontrollant tilldelas en ny offentlig IP-adress. Om du vill behålla användningen av den offentliga IP-adressen kan du i stället skapa en ingress-kontrollant med en statisk offentlig IP-adress.

Hämta den offentliga IP-adressen med kubectl get service kommandot .

kubectl --namespace ingress-basic get services -o wide -w nginx-ingress-ingress-nginx-controller

Det tar några minuter för IP-adressen att tilldelas till tjänsten.

$ kubectl --namespace ingress-basic get services -o wide -w nginx-ingress-ingress-nginx-controller

NAME                                     TYPE           CLUSTER-IP    EXTERNAL-IP     PORT(S)                      AGE   SELECTOR
nginx-ingress-ingress-nginx-controller   LoadBalancer   10.0.74.133   EXTERNAL_IP     80:32486/TCP,443:30953/TCP   44s   app.kubernetes.io/component=controller,app.kubernetes.io/instance=nginx-ingress,app.kubernetes.io/name=ingress-nginx

Anteckna den här offentliga IP-adressen eftersom den används i det sista steget för att testa distributionen.

Inga inkommande regler har skapats ännu. Om du bläddrar till den offentliga IP-adressen visas NGINX-ingresskontrollantens standardsida 404.

Generera TLS-certifikat

I den här artikeln ska vi generera ett själv signerat certifikat med openssl . För produktionsanvändning bör du begära ett betrott, signerat certifikat via en provider eller din egen certifikatutfärdare (CA). I nästa steg genererar du en Kubernetes-hemlighet med hjälp av TLS-certifikatet och den privata nyckeln som genereras av OpenSSL.

I följande exempel genereras ett 2 048-bitars RSA X509-certifikat som är giltigt i 365 dagar med namnet aks-ingress-tls.crt. Den privata nyckelfilen heter aks-ingress-tls.key. En Kubernetes TLS-hemlighet kräver båda dessa filer.

Den här artikeln demo.azure.com ämnesnamnet och behöver inte ändras. För produktionsanvändning anger du egna organisationsvärden för -subj parametern :

openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
    -out aks-ingress-tls.crt \
    -keyout aks-ingress-tls.key \
    -subj "/CN=demo.azure.com/O=aks-ingress-tls"

Skapa Kubernetes-hemlighet för TLS-certifikat

Om du vill tillåta kubernetes att använda TLS-certifikatet och den privata nyckeln för ingress-kontrollanten skapar och använder du en hemlighet. Hemligheten definieras en gång och använder certifikatet och nyckelfilen som skapades i föregående steg. Du refererar sedan till den här hemligheten när du definierar ingressvägar.

I följande exempel skapas ett hemligt namn aks-ingress-tls:

kubectl create secret tls aks-ingress-tls \
    --namespace ingress-basic \
    --key aks-ingress-tls.key \
    --cert aks-ingress-tls.crt

Köra demoprogram

En ingresskontrollant och en hemlighet med ditt certifikat har konfigurerats. Nu ska vi köra två demoprogram i ditt AKS-kluster. I det här exemplet används Helm för att distribuera två instanser av ett enkelt Hello World-program.

Om du vill se hur ingress-kontrollanten används kör du två demoprogram i ditt AKS-kluster. I det här exemplet använder du kubectl apply för att distribuera två instanser av ett enkelt Hello World-program.

Skapa en aks-helloworld.yaml-fil och kopiera följande YAML-exempel:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: aks-helloworld
spec:
  replicas: 1
  selector:
    matchLabels:
      app: aks-helloworld
  template:
    metadata:
      labels:
        app: aks-helloworld
    spec:
      containers:
      - name: aks-helloworld
        image: mcr.microsoft.com/azuredocs/aks-helloworld:v1
        ports:
        - containerPort: 80
        env:
        - name: TITLE
          value: "Welcome to Azure Kubernetes Service (AKS)"
---
apiVersion: v1
kind: Service
metadata:
  name: aks-helloworld
spec:
  type: ClusterIP
  ports:
  - port: 80
  selector:
    app: aks-helloworld

Skapa en ingress-demo.yaml-fil och kopiera följande YAML-exempel:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ingress-demo
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ingress-demo
  template:
    metadata:
      labels:
        app: ingress-demo
    spec:
      containers:
      - name: ingress-demo
        image: mcr.microsoft.com/azuredocs/aks-helloworld:v1
        ports:
        - containerPort: 80
        env:
        - name: TITLE
          value: "AKS Ingress Demo"
---
apiVersion: v1
kind: Service
metadata:
  name: ingress-demo
spec:
  type: ClusterIP
  ports:
  - port: 80
  selector:
    app: ingress-demo

Kör de två demoprogrammen med kubectl apply :

kubectl apply -f aks-helloworld.yaml --namespace ingress-basic
kubectl apply -f ingress-demo.yaml --namespace ingress-basic

Skapa en ingressväg

Båda programmen körs nu i Kubernetes-klustret, men de är konfigurerade med en tjänst av typen ClusterIP . Därför är programmen inte tillgängliga från Internet. Om du vill göra dem offentligt tillgängliga skapar du en Kubernetes-ingressresurs. Ingressresursen konfigurerar reglerna som dirigerar trafik till ett av de två programmen.

I följande exempel dirigeras trafik till https://demo.azure.com/ adressen till tjänsten med namnet aks-helloworld . Trafik till adressen https://demo.azure.com/hello-world-two dirigeras till ingress-demo tjänsten. I den här artikeln behöver du inte ändra demovärdnamnen. För produktionsanvändning anger du de namn som anges som en del av certifikatbegäran och genereringsprocessen.

Tips

Om värdnamnet som angavs under certifikatbegäranprocessen, CN-namnet, inte matchar värden som definierats i din ingressväg, visar ingress-kontrollanten en Varning om falska Kubernetes-indatakontrollanter. Kontrollera att certifikat- och ingressvägsvärdnamnen matchar.

Avsnittet tls talar om för ingressvägen att använda hemligheten med namnet aks-ingress-tls för värden demo.azure.com. För produktionsanvändning anger du återigen din egen värdadress.

Skapa en fil med hello-world-ingress.yaml namnet och kopiera i följande YAML-exempel.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: hello-world-ingress
  namespace: ingress-basic
  annotations:
    kubernetes.io/ingress.class: nginx
    nginx.ingress.kubernetes.io/use-regex: "true"
    nginx.ingress.kubernetes.io/rewrite-target: /$2
spec:
  tls:
  - hosts:
    - demo.azure.com
    secretName: aks-ingress-tls
  rules:
  - host: demo.azure.com
    http:
      paths:
      - path: /hello-world-one(/|$)(.*)
        pathType: Prefix
        backend:
          service:
            name: aks-helloworld
            port:
              number: 80
      - path: /hello-world-two(/|$)(.*)
        pathType: Prefix
        backend:
          service:
            name: ingress-demo
            port:
              number: 80
      - path: /(.*)
        pathType: Prefix
        backend:
          service:
            name: aks-helloworld
            port:
              number: 80

Skapa ingressresursen med kubectl apply -f hello-world-ingress.yaml kommandot .

kubectl apply -f hello-world-ingress.yaml

Exempelutdata visar att ingressresursen har skapats.

$ kubectl apply -f hello-world-ingress.yaml

ingress.extensions/hello-world-ingress created

Testa ingresskonfigurationen

Om du vill testa certifikaten med vår falska demo.azure.com värd använder du och anger curl parametern --resolve. Med den här parametern kan demo.azure.com mappa namnet till den offentliga IP-adressen för ingress-kontrollanten. Ange den offentliga IP-adressen för din egen ingress-kontrollant, som du ser i följande exempel:

curl -v -k --resolve demo.azure.com:443:EXTERNAL_IP https://demo.azure.com

Ingen ytterligare sökväg angavs med adressen, så ingress-kontrollanten använder vägen som / standard. Det första demoprogrammet returneras, som du ser i följande komprimerade exempelutdata:

$ curl -v -k --resolve demo.azure.com:443:EXTERNAL_IP https://demo.azure.com

[...]
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <link rel="stylesheet" type="text/css" href="/static/default.css">
    <title>Welcome to Azure Kubernetes Service (AKS)</title>
[...]

Parametern -v i vårt curl kommando matar ut utförlig information, inklusive det mottagna TLS-certifikatet. Halvvägs genom curl-utdata kan du kontrollera att ditt eget TLS-certifikat har använts. Parametern -k fortsätter att läsa in sidan även om vi använder ett själv signerat certifikat. Följande exempel visar att utfärdaren: CN=demo.azure.com; O=aks-ingress-tls-certifikatet användes:

[...]
* Server certificate:
*  subject: CN=demo.azure.com; O=aks-ingress-tls
*  start date: Oct 22 22:13:54 2018 GMT
*  expire date: Oct 22 22:13:54 2019 GMT
*  issuer: CN=demo.azure.com; O=aks-ingress-tls
*  SSL certificate verify result: self signed certificate (18), continuing anyway.
[...]

Lägg nu till /hello-world-two-sökvägen till adressen, till exempel https://demo.azure.com/hello-world-two . Det andra demoprogrammet med den anpassade rubriken returneras, som du ser i följande komprimerade exempelutdata:

$ curl -v -k --resolve demo.azure.com:443:EXTERNAL_IP https://demo.azure.com/hello-world-two

[...]
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <link rel="stylesheet" type="text/css" href="/static/default.css">
    <title>AKS Ingress Demo</title>
[...]

Rensa resurser

Den här artikeln använde Helm för att installera ingresskomponenterna och exempelapparna. När du distribuerar ett Helm-diagram skapas ett antal Kubernetes-resurser. Dessa resurser omfattar poddar, distributioner och tjänster. Om du vill rensa resurserna kan du antingen ta bort hela exempelnamnrymden eller de enskilda resurserna.

Ta bort exempelnamnområdet och alla resurser

Om du vill ta bort hela exempelnamnrymden använder kubectl delete du kommandot och anger namnet på namnområdet. Alla resurser i namnområdet tas bort.

kubectl delete namespace ingress-basic

Ta bort resurser individuellt

En mer detaljerad metod kan också vara att ta bort de enskilda resurser som skapats. Visa en lista över Helm-versioner med helm list kommandot .

helm list --namespace ingress-basic

Leta efter diagram med namnet nginx-ingress enligt följande exempelutdata:

$ helm list --namespace ingress-basic

NAME                    NAMESPACE       REVISION        UPDATED                                 STATUS          CHART                   APP VERSION
nginx-ingress           ingress-basic   1               2020-01-06 19:55:46.358275 -0600 CST    deployed        nginx-ingress-1.27.1    0.26.1

Avinstallera versionerna med helm uninstall kommandot .

helm uninstall nginx-ingress --namespace ingress-basic

I följande exempel avinstalleras NGINX-ingressdistributionen.

$ helm uninstall nginx-ingress --namespace ingress-basic

release "nginx-ingress" uninstalled

Ta sedan bort de två exempelprogrammen:

kubectl delete -f aks-helloworld.yaml --namespace ingress-basic
kubectl delete -f ingress-demo.yaml --namespace ingress-basic

Ta bort den ingressväg som dirigerade trafik till exempelapparna:

kubectl delete -f hello-world-ingress.yaml

Ta bort certifikathemligheten:

kubectl delete secret aks-ingress-tls --namespace ingress-basic

Slutligen kan du ta bort själva namnområdet. Använd kommandot kubectl delete och ange namnet på namnområdet:

kubectl delete namespace ingress-basic

Nästa steg

Den här artikeln innehåller några externa komponenter till AKS. Mer information om dessa komponenter finns på följande projektsidor:

Du kan även: