Dela via

Använda TLS med en ingresskontrollant i Azure Kubernetes Service (AKS)

  • Artikel

TLS-protokollet (Transport Layer Security) använder certifikat för att ge säkerhet för kommunikation, kryptering, autentisering och integritet. Genom att använda TLS med en ingresskontrollant på AKS kan du skydda kommunikationen mellan dina program och uppleva fördelarna med en ingresskontrollant.

Du kan ta med egna certifikat och integrera dem med CSI-drivrutinen för Secrets Store. Du kan också använda cert-manager, som automatiskt genererar och konfigurerar Let's Encrypt-certifikat . Två program körs i AKS-klustret, som var och en är tillgänglig via en enda IP-adress.

Viktigt!

Tillägget Programroutning rekommenderas för ingress i AKS. Mer information finns i Hanterad nginx-ingress med tillägget för programroutning.

Viktigt!

Microsoft hanterar eller stöder inte cert-manager och eventuella problem som beror på dess användning. Information om problem med cert-manager finns i felsökningsdokumentationen för cert-manager.

Det finns två öppen källkod ingresskontrollanter för Kubernetes baserat på Nginx: en underhålls av Kubernetes-communityn (kubernetes/ingress-nginx), och en underhålls av NGINX, Inc. (nginxinc/kubernetes-ingress). Den här artikeln använder kubernetes community-ingresskontrollanten.

Innan du börjar

  • Den här artikeln förutsätter att du har en ingresskontrollant och program konfigurerade. Om du behöver en ingresskontrollant eller exempelprogram kan du läsa Skapa en ingresskontrollant.

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

  • Den här artikeln förutsätter att du har ett befintligt AKS-kluster med ett integrerat Azure Container Registry (ACR). Mer information om hur du skapar ett AKS-kluster med en integrerad ACR finns i Autentisera med ACR från AKS.

  • Om du använder Azure CLI kräver den här artikeln 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.

  • Om du använder Azure PowerShell kräver den här artikeln att du kör Azure PowerShell version 5.9.0 eller senare. Kör Get-InstalledModule -Name Az för att hitta versionen. Om du behöver installera eller uppgradera kan du läsa Install Azure PowerShell (Installera Azure PowerShell).

Använda TLS med egna certifikat med CSI-drivrutinen för Secrets Store

Om du vill använda TLS med egna certifikat med CSI-drivrutinen för Secrets Store behöver du ett AKS-kluster med CSI-drivrutinen Secrets Store konfigurerad och en Azure Key Vault-instans.

Mer information finns i Konfigurera CSI-drivrutin för Secrets Store för att aktivera NGINX-ingresskontrollant med TLS.

Använda TLS med Let's Encrypt-certifikat

Om du vill använda TLS med Let's Encrypt-certifikat distribuerar du cert-manager, som automatiskt genererar och konfigurerar Let's Encrypt-certifikat.

Importera cert-manager-avbildningarna som används av Helm-diagrammet till din ACR

  • Använd az acr import för att importera följande bilder till din ACR.

    REGISTRY_NAME=<REGISTRY_NAME>
CERT_MANAGER_REGISTRY=quay.io
CERT_MANAGER_TAG=v1.8.0
CERT_MANAGER_IMAGE_CONTROLLER=jetstack/cert-manager-controller
CERT_MANAGER_IMAGE_WEBHOOK=jetstack/cert-manager-webhook
CERT_MANAGER_IMAGE_CAINJECTOR=jetstack/cert-manager-cainjector

az acr import --name $REGISTRY_NAME --source $CERT_MANAGER_REGISTRY/$CERT_MANAGER_IMAGE_CONTROLLER:$CERT_MANAGER_TAG --image $CERT_MANAGER_IMAGE_CONTROLLER:$CERT_MANAGER_TAG
az acr import --name $REGISTRY_NAME --source $CERT_MANAGER_REGISTRY/$CERT_MANAGER_IMAGE_WEBHOOK:$CERT_MANAGER_TAG --image $CERT_MANAGER_IMAGE_WEBHOOK:$CERT_MANAGER_TAG
az acr import --name $REGISTRY_NAME --source $CERT_MANAGER_REGISTRY/$CERT_MANAGER_IMAGE_CAINJECTOR:$CERT_MANAGER_TAG --image $CERT_MANAGER_IMAGE_CAINJECTOR:$CERT_MANAGER_TAG

Kommentar

Du kan också importera Helm-diagram till din ACR. Mer information finns i Skicka och hämta Helm-diagram till en ACR.

Konfigurationsalternativ för ingresskontrollant

Du kan konfigurera din NGINX-ingresskontrollant med antingen en statisk offentlig IP-adress eller en dynamisk offentlig IP-adress. Om du använder en anpassad domän måste du lägga till en A-post i DNS-zonen. Om du inte använder en anpassad domän kan du konfigurera ett fullständigt domännamn (FQDN) för ingresskontrollantens IP-adress.

Skapa en statisk eller dynamisk offentlig IP-adress

Använda en statisk offentlig IP-adress

Du kan konfigurera ingresskontrollanten med en statisk offentlig IP-adress. Den statiska offentliga IP-adressen finns kvar om du tar bort ingresskontrollanten. IP-adressen finns inte kvar om du tar bort AKS-klustret.

När du uppgraderar ingresskontrollanten måste du skicka en parameter till Helm-versionen för att säkerställa att ingresskontrollanttjänsten blir medveten om lastbalanseraren som ska allokeras till den. För att HTTPS-certifikaten ska fungera korrekt använder du en DNS-etikett för att konfigurera ett FQDN för ingresskontrollantens IP-adress.

  1. Hämta resursgruppens namn på AKS-klustret med az aks show kommandot .

    az aks show --resource-group myResourceGroup --name myAKSCluster --query nodeResourceGroup -o tsv

  2. Skapa en offentlig IP-adress med den statiska allokeringsmetoden med kommandot az network public-ip create . I följande exempel skapas en offentlig IP-adress med namnet myAKSPublicIP i aks-klusterresursgruppen som hämtades i föregående steg.

    az network public-ip create --resource-group MC_myResourceGroup_myAKSCluster_eastus --name myAKSPublicIP --sku Standard --allocation-method static --query publicIp.ipAddress -o tsv

Kommentar

Du kan också skapa en IP-adress i en annan resursgrupp, som du kan hantera separat från ditt AKS-kluster. Om du skapar en IP-adress i en annan resursgrupp kontrollerar du att följande är sant:

  • Klusteridentiteten som används av AKS-klustret har delegerade behörigheter till resursgruppen, till exempel Nätverksdeltagare.
  • Lägg till parametern --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-load-balancer-resource-group"="<RESOURCE_GROUP>" . Ersätt <RESOURCE_GROUP> med namnet på resursgruppen där IP-adressen finns.

  1. Lägg till parametern --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-dns-label-name"="<DNS_LABEL>" . DNS-etiketten kan anges antingen när ingresskontrollanten först distribueras eller så kan den konfigureras senare.

  2. Lägg till parametern --set controller.service.loadBalancerIP="<STATIC_IP>" . Ange din egen offentliga IP-adress som skapades i föregående steg.

    DNS_LABEL="<DNS_LABEL>"
NAMESPACE="ingress-basic"
STATIC_IP=<STATIC_IP>

helm upgrade ingress-nginx ingress-nginx/ingress-nginx \
  --namespace $NAMESPACE \
  --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-dns-label-name"=$DNS_LABEL \
  --set controller.service.loadBalancerIP=$STATIC_IP \
  --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-load-balancer-health-probe-request-path"=/healthz

Mer information finns i Använda en statisk offentlig IP-adress och DNS-etikett med AKS-lastbalanseraren.

Använda en dynamisk offentlig IP-adress

En offentlig IP-adress i Azure skapas för ingresskontrollanten när den skapas. Den offentliga IP-adressen är statisk för ingresskontrollantens livslängd. Den offentliga IP-adressen finns inte kvar om du tar bort ingresskontrollanten. Om du skapar en ny ingresskontrollant tilldelas den en ny offentlig IP-adress. Dina utdata bör se ut ungefär som följande exempelutdata.

  • kubectl get service Använd kommandot för att hämta den offentliga IP-adressen för ingresskontrollanten.

    # Get the public IP address for your ingress controller

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

# Sample output

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

Lägga till en A-post i DNS-zonen

Om du använder en anpassad domän måste du lägga till en A-post i DNS-zonen. Om du inte använder en anpassad domän kan du konfigurera den offentliga IP-adressen med ett FQDN.

  • Lägg till en A-post i DNS-zonen med den externa IP-adressen för NGINX-tjänsten med .az network dns record-set a add-record

    az network dns record-set a add-record \
    --resource-group myResourceGroup \
    --zone-name MY_CUSTOM_DOMAIN \
    --record-set-name "*" \
    --ipv4-address MY_EXTERNAL_IP

Konfigurera ett FQDN för ingresskontrollanten

Du kan också konfigurera ett FQDN för ingresskontrollantens IP-adress i stället för en anpassad domän genom att ange en DNS-etikett. Ditt FQDN bör följa det här formuläret: <CUSTOM DNS LABEL>.<AZURE REGION NAME>.cloudapp.azure.com.

Viktigt!

DNS-etiketten måste vara unik på dess Azure-plats.

Du kan konfigurera ditt fullständiga domännamn med någon av följande metoder:

  • Ange DNS-etiketten med Hjälp av Azure CLI eller Azure PowerShell.
  • Ange DNS-etiketten med hjälp av Helm-diagraminställningar.

Mer information finns i Dns-namnetiketter för offentlig IP-adress.

Ange DNS-etiketten med Hjälp av Azure CLI eller Azure PowerShell

Ersätt <DNS_LABEL> med din unika DNS-etikett.

# Public IP address of your ingress controller
IP="MY_EXTERNAL_IP"

# Name to associate with public IP address
DNSLABEL="<DNS_LABEL>"

# Get the resource-id of the public IP
PUBLICIPID=$(az network public-ip list --query "[?ipAddress!=null]|[?contains(ipAddress, '$IP')].[id]" --output tsv)

# Update public IP address with DNS name
az network public-ip update --ids $PUBLICIPID --dns-name $DNSLABEL

# Display the FQDN
az network public-ip show --ids $PUBLICIPID --query "[dnsSettings.fqdn]" --output tsv

Ange DNS-etiketten med hjälp av Helm-diagraminställningar

Du kan skicka en anteckningsinställning till helm-diagramkonfigurationen med hjälp av parametern --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-dns-label-name" . Den här parametern kan anges när ingresskontrollanten först distribueras, eller så kan den konfigureras senare.

I följande exempel visas hur du uppdaterar den här inställningen när kontrollanten har distribuerats. Ersätt <DNS_LABEL> med din unika DNS-etikett.

DNSLABEL="<DNS_LABEL>"
NAMESPACE="ingress-basic"

helm upgrade ingress-nginx ingress-nginx/ingress-nginx \
  --namespace $NAMESPACE \
  --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-dns-label-name"=$DNSLABEL \
  --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-load-balancer-health-probe-request-path"=/healthz

Installera cert-manager

NGINX-ingresskontrollanten stöder TLS-avslutning. Det finns flera sätt att hämta och konfigurera certifikat för HTTPS. Den här artikeln använder cert-manager, som tillhandahåller automatisk Lets Encrypt-certifikatgenerering och hanteringsfunktioner.

Om du vill installera cert-manager-kontrollanten använder du följande kommandon.

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

# Label the ingress-basic namespace to disable resource validation
kubectl label namespace ingress-basic cert-manager.io/disable-validation=true

# Add the Jetstack Helm repository
helm repo add jetstack https://charts.jetstack.io

# Update your local Helm chart repository cache
helm repo update

# Install the cert-manager Helm chart
helm install cert-manager jetstack/cert-manager \
  --namespace ingress-basic \
  --version=$CERT_MANAGER_TAG \
  --set installCRDs=true \
  --set nodeSelector."kubernetes\.io/os"=linux \
  --set image.repository=$ACR_URL/$CERT_MANAGER_IMAGE_CONTROLLER \
  --set image.tag=$CERT_MANAGER_TAG \
  --set webhook.image.repository=$ACR_URL/$CERT_MANAGER_IMAGE_WEBHOOK \
  --set webhook.image.tag=$CERT_MANAGER_TAG \
  --set cainjector.image.repository=$ACR_URL/$CERT_MANAGER_IMAGE_CAINJECTOR \
  --set cainjector.image.tag=$CERT_MANAGER_TAG

Mer information om cert-manager-konfiguration finns i cert-manager-projektet.

Skapa en utfärdare av CA-kluster

Innan certifikat kan utfärdas kräver cert-manager någon av följande utfärdare:

Mer information finns i dokumentationen för utfärdare av certifikatutfärdare .

  1. Skapa en kluster utfärdare, till exempel cluster-issuer.yaml, med hjälp av följande exempelmanifest. Ersätt MY_EMAIL_ADDRESS med en giltig adress från din organisation.

    apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: letsencrypt
spec:
  acme:
    server: https://acme-v02.api.letsencrypt.org/directory
    email: MY_EMAIL_ADDRESS
    privateKeySecretRef:
      name: letsencrypt
    solvers:
    - http01:
        ingress:
          class: nginx
          podTemplate:
            spec:
              nodeSelector:
                "kubernetes.io/os": linux

  2. Använd utfärdaren med kommandot kubectl apply .

    kubectl apply -f cluster-issuer.yaml --namespace ingress-basic

Uppdatera dina ingressvägar

Du måste uppdatera dina inkommande vägar för att hantera trafik till ditt fullständiga domännamn eller din anpassade domän.

I följande exempel dirigeras trafik som sådan:

  • Trafik till hello-world-ingress. MY_CUSTOM_DOMAIN dirigeras till tjänsten aks-helloworld-one .
  • Trafik till hello-world-ingress. MY_CUSTOM_DOMAIN/hello-world-two dirigeras till tjänsten aks-helloworld-two .
  • Trafik till hello-world-ingress. MY_CUSTOM_DOMAIN/statisk dirigeras till tjänsten med namnet aks-helloworld-one för statiska tillgångar.

Kommentar

Om du har konfigurerat ett FQDN för ingresskontrollantens IP-adress i stället för en anpassad domän använder du FQDN i stället för hello-world-ingress. MY_CUSTOM_DOMAIN.

Om ditt fullständiga domännamn till exempel är demo-aks-ingress.eastus.cloudapp.azure.com ersätter du hello-world-ingress. MY_CUSTOM_DOMAIN med demo-aks-ingress.eastus.cloudapp.azure.com i hello-world-ingress.yaml.

  1. Skapa eller uppdatera hello-world-ingress.yaml filen med hjälp av följande YAML-exempelfil. spec.tls.hosts Uppdatera och spec.rules.host till det DNS-namn som du skapade i ett tidigare steg.

    apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: hello-world-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /$2
    nginx.ingress.kubernetes.io/use-regex: "true"
    cert-manager.io/cluster-issuer: letsencrypt
spec:
  ingressClassName: nginx
  tls:
  - hosts:
    - hello-world-ingress.MY_CUSTOM_DOMAIN
    secretName: tls-secret
  rules:
  - host: hello-world-ingress.MY_CUSTOM_DOMAIN
    http:
      paths:
      - path: /hello-world-one(/|$)(.*)
        pathType: Prefix
        backend:
          service:
            name: aks-helloworld-one
            port:
              number: 80
      - path: /hello-world-two(/|$)(.*)
        pathType: Prefix
        backend:
          service:
            name: aks-helloworld-two
            port:
              number: 80
      - path: /(.*)
        pathType: Prefix
        backend:
          service:
            name: aks-helloworld-one
            port:
              number: 80
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: hello-world-ingress-static
  annotations:
    nginx.ingress.kubernetes.io/ssl-redirect: "false"
    nginx.ingress.kubernetes.io/rewrite-target: /static/$2
spec:
  ingressClassName: nginx
  tls:
  - hosts:
    - hello-world-ingress.MY_CUSTOM_DOMAIN
    secretName: tls-secret
  rules:
  - host: hello-world-ingress.MY_CUSTOM_DOMAIN
    http:
      paths:
      - path: /static(/|$)(.*)
        pathType: Prefix
        backend:
          service:
            name: aks-helloworld-one
            port:
              number: 80

  2. Uppdatera ingressresursen kubectl apply med kommandot .

    kubectl apply -f hello-world-ingress.yaml --namespace ingress-basic

Kontrollera att ett certifikatobjekt har skapats

Därefter måste en certifikatresurs skapas. Certifikatresursen definierar önskat X.509-certifikat. Mer information finns i certifikat för cert-manager.

Cert-manager skapar automatiskt ett certifikatobjekt åt dig med ingress-shim, som distribueras automatiskt med cert-manager sedan v0.2.2. Mer information finns i ingress-shim-dokumentationen.

Kontrollera att certifikatet har skapats genom att använda kubectl get certificate --namespace ingress-basic kommandot och kontrollera att READY är Sant. Det kan ta flera minuter att hämta utdata.

kubectl get certificate --namespace ingress-basic

Följande utdata visar certifikatets status.

NAME         READY   SECRET       AGE
tls-secret   True    tls-secret   11m

Testa ingresskonfigurationen

Öppna en webbläsare för att hello-world-ingress. MY_CUSTOM_DOMAIN eller FQDN för din Kubernetes-ingresskontrollant. Kontrollera att följande är sant:

  • Du omdirigeras för att använda HTTPS.
  • Certifikatet är betrott.
  • Demoprogrammet visas i webbläsaren.
  • Lägg till /hello-world-two i slutet av domänen och se till att det andra demoprogrammet med den anpassade rubriken visas.

Rensa resurser

Den här artikeln använde Helm för att installera ingresskomponenter, certifikat och exempelappar. När du distribuerar ett Helm-diagram skapas många Kubernetes-resurser. Dessa resurser omfattar poddar, distributioner och tjänster. Om du vill rensa dessa resurser kan du antingen ta bort hela exempelnamnområdet eller de enskilda resurserna.

Ta bort exempelnamnområdet och alla resurser

Om du tar bort exempelnamnområdet tas även alla resurser i namnområdet bort.

  • Ta bort hela exempelnamnområdet med kommandot kubectl delete och ange namnområdesnamnet.

    kubectl delete namespace ingress-basic

Ta bort resurser individuellt

Du kan också ta bort resursen individuellt.

  1. Ta bort klusterproblemastreringsresurserna.

    kubectl delete -f cluster-issuer.yaml --namespace ingress-basic

  2. Visa en lista över Helm-versionerna helm list med kommandot . Leta efter diagram med namnet nginx och cert-manager, som du ser i följande exempelutdata.

    $ helm list --namespace ingress-basic

NAME                    NAMESPACE       REVISION        UPDATED                                 STATUS          CHART                   APP VERSION
cert-manager            ingress-basic   1               2020-01-15 10:23:36.515514 -0600 CST    deployed        cert-manager-v0.13.0    v0.13.0
nginx                   ingress-basic   1               2020-01-15 10:09:45.982693 -0600 CST    deployed        nginx-ingress-1.29.1    0.27.0

  3. Avinstallera versionerna med kommandot helm uninstall . I följande exempel avinstalleras NGINX-ingress- och cert-manager-distributionerna.

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

release "cert-manager" uninstalled
release "nginx" uninstalled

  4. Ta bort de två exempelprogrammen.

    kubectl delete -f aks-helloworld-one.yaml --namespace ingress-basic
kubectl delete -f aks-helloworld-two.yaml --namespace ingress-basic

  5. Ta bort den inkommande vägen som dirigerade trafik till exempelapparna.

    kubectl delete -f hello-world-ingress.yaml --namespace ingress-basic

  6. Ta bort själva namnområdet. kubectl delete Använd kommandot och ange namnområdets namn.

    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: