Skapa en ingångskontrollant med en statisk offentlig IP-adress i AKS (Azure Kubernetes service)

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 ingress-kontrollanten i ett Azure Kubernetes Service-kluster (AKS). Ingress-kontrollanten är konfigurerad med en statisk offentlig IP-adress. Cert-Manager-projektet används för att automatiskt generera och konfigurera Let's Encrypt-certifikat. Slutligen körs två program i AKS-klustret, som var och en kan nås via en enda IP-adress.

Du kan även:

• Skapa en grundläggande ingress-kontrollant med extern nätverksanslutning
• Aktivera tillägget för HTTP-programroutning
• Skapa en ingress-kontrollant som använder dina egna TLS-certifikat
• Skapa en ingress-kontrollant som använder Let's Encrypt för att automatiskt generera TLS-certifikat med en dynamisk offentlig IP-adress

Innan du börjar

Den här artikeln förutsätter att du har ett befintligt AKS-kluster. Om du behöver ett AKS-kluster kan du gå till AKS-snabbstarten med Hjälp av Azure CLI eller använda Azure Portal.

Den här artikeln använder Helm 3 för att installera NGINX-indatakontrollanten på en version av Kubernetes som stöds. Kontrollera att du använder den senaste versionen av Helm och har åtkomst till Helm-lagringsplatsen ingress-nginx och jetstack. 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). Uppgraderingsanvisningar finns i installationsdokumenten för Helm.

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 avbildningarna som används av Helm-diagrammet till ditt 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 ditt ACR.

REGISTRY_NAME=<REGISTRY_NAME>
CONTROLLER_REGISTRY=k8s.gcr.io
CONTROLLER_IMAGE=ingress-nginx/controller
CONTROLLER_TAG=v1.0.4
PATCH_REGISTRY=docker.io
PATCH_IMAGE=jettech/kube-webhook-certgen
PATCH_TAG=v1.5.2
DEFAULTBACKEND_REGISTRY=k8s.gcr.io
DEFAULTBACKEND_IMAGE=defaultbackend-amd64
DEFAULTBACKEND_TAG=1.5
CERT_MANAGER_REGISTRY=quay.io
CERT_MANAGER_TAG=v1.5.4
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 $CONTROLLER_REGISTRY/$CONTROLLER_IMAGE:$CONTROLLER_TAG --image $CONTROLLER_IMAGE:$CONTROLLER_TAG
az acr import --name $REGISTRY_NAME --source $PATCH_REGISTRY/$PATCH_IMAGE:$PATCH_TAG --image $PATCH_IMAGE:$PATCH_TAG
az acr import --name $REGISTRY_NAME --source $DEFAULTBACKEND_REGISTRY/$DEFAULTBACKEND_IMAGE:$DEFAULTBACKEND_TAG --image $DEFAULTBACKEND_IMAGE:$DEFAULTBACKEND_TAG
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

Skapa en ingress-kontrollant

Som standard skapas en NGINX-ingresskontrollant med en ny tilldelning av offentlig IP-adress. Den här offentliga IP-adressen är endast statisk för ingress-kontrollantens livslängd och går förlorad om kontrollanten tas bort och skapas på nytt. Ett vanligt konfigurationskrav är att ge NGINX-inress-kontrollanten en befintlig statisk offentlig IP-adress. Den statiska offentliga IP-adressen finns kvar om ingress-kontrollanten tas bort. Med den här metoden kan du använda befintliga DNS-poster och nätverkskonfigurationer på ett konsekvent sätt under hela livscykeln för dina program.

Om du behöver skapa en statisk offentlig IP-adress hämtar du först resursgruppens namn för AKS-klustret med kommandot az aks show:

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

Skapa sedan 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 du fick 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

Distribuera nu nginx-ingress-diagrammet med Helm. 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.

IP- och DNS-etikett

Du måste skicka två ytterligare parametrar till Helm-versionen så att indatakontrollanten blir medveten om både den statiska IP-adressen för lastbalanseraren som ska allokeras till indatakontrollanttjänsten och dns-namnetiketten som tillämpas på den offentliga IP-adressresursen. För att HTTPS-certifikaten ska fungera korrekt används en DNS-namnetikett för att konfigurera ett FQDN för ingresskontrollantens IP-adress.

1. Lägg till --set controller.service.loadBalancerIP parametern . Ange din egen offentliga IP-adress som skapades i föregående steg.
2. Lägg till --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-dns-label-name" parametern . Ange en DNS-namnetikett som ska tillämpas på den offentliga IP-adress som skapades i föregående steg. Den här etiketten skapar ett DNS-namn för formuläret <LABEL>.<AZURE REGION NAME>.cloudapp.azure.com

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.

Uppdatera följande skript med IP-adressen för ingress-kontrollanten och ett unikt namn som du vill använda för FQDN-prefixet.

# 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>
STATIC_IP=<STATIC_IP>
DNS_LABEL=<DNS_LABEL>

# 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="" \
    --set controller.service.loadBalancerIP=$STATIC_IP \
    --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-dns-label-name"=$DNS_LABEL

När Kubernetes-lastbalanseringstjänsten skapas för NGINX-indatakontrollanten tilldelas din statiska IP-adress, som du ser i följande exempelutdata:

$ 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

Inga inkommande regler har skapats ännu, så NGINX-inkommande styrenhetens standardsida 404 visas om du bläddrar till den offentliga IP-adressen. Ingress-regler konfigureras i följande steg.

Du kan kontrollera att DNS-namnetiketten har tillämpats genom att fråga FQDN på den offentliga IP-adressen på följande sätt:

az network public-ip list --resource-group MC_myResourceGroup_myAKSCluster_eastus --query "[?name=='myAKSPublicIP'].[dnsSettings.fqdn]" -o tsv

Ingress-kontrollanten är nu tillgänglig via IP-adressen eller FQDN.

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 visar hur du använder cert-manager, som tillhandahåller automatisk lets encrypt certificate generation and management functionality (Låter kryptera certifikatgenerering och hanteringsfunktioner).

Om du vill installera cert-manager-kontrollanten i ett Kubernetes RBAC-aktiverat kluster använder du följande helm install kommando:

# Label the cert-manager 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 CA-klusterutfärdare

Innan certifikat kan utfärdas kräver cert-manager en Issuer- eller ClusterIssuer-resurs. Dessa Kubernetes-resurser är identiska i funktioner, men fungerar i ett enda Issuer namnområde och ClusterIssuer fungerar i alla namnområden. Mer information finns i dokumentationen för cert-manager issuer.

Skapa en klusterutfärdare, till exempel cluster-issuer.yaml , med hjälp av följande exempelmanifest. Uppdatera e-postadressen med en giltig adress från din organisation:

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

Använd kommandot för att skapa kubectl apply utfärdaren.

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

Utdata bör likna det här exemplet:

clusterissuer.cert-manager.io/letsencrypt-staging created

Köra demoprogram

En ingress-kontrollant och en certifikathanteringslösning 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 ingressresurs för Kubernetes. Ingressresursen konfigurerar reglerna som dirigerar trafik till ett av de två programmen.

I följande exempel dirigeras trafik till adressen https://demo-aks-ingress.eastus.cloudapp.azure.com/ till tjänsten med namnet aks-helloworld . Trafik till adressen https://demo-aks-ingress.eastus.cloudapp.azure.com/hello-world-two dirigeras till ingress-demo tjänsten. Uppdatera värdarna och värden till DNS-namnet som du skapade i föregående steg.

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

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: hello-world-ingress
  annotations:
    kubernetes.io/ingress.class: nginx
    cert-manager.io/cluster-issuer: letsencrypt-staging
    nginx.ingress.kubernetes.io/rewrite-target: /$1
    nginx.ingress.kubernetes.io/use-regex: "true"
spec:
  tls:
  - hosts:
    - demo-aks-ingress.eastus.cloudapp.azure.com
    secretName: tls-secret
  rules:
  - host: demo-aks-ingress.eastus.cloudapp.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 kommandot .

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

Utdata bör likna det här exemplet:

ingress.extensions/hello-world-ingress created

Verifiera certifikatobjektet

Därefter måste en certifikatresurs skapas. Certifikatresursen definierar det önskade X.509-certifikatet. Mer information finns i cert-manager-certifikat.

Cert-manager har förmodligen automatiskt skapat ett certifikatobjekt åt dig med hjälp av ingress-shim, som distribueras automatiskt med cert-manager sedan v0.2.2. Mer information finns i dokumentationen om ingress-shim.

Kontrollera att certifikatet har skapats med hjälp av kubectl describe certificate tls-secret --namespace ingress-basic kommandot .

Om certifikatet har utfärdats visas utdata som liknar följande:

Type    Reason          Age   From          Message
----    ------          ----  ----          -------
  Normal  CreateOrder     11m   cert-manager  Created new ACME order, attempting validation...
  Normal  DomainVerified  10m   cert-manager  Domain "demo-aks-ingress.eastus.cloudapp.azure.com" verified with "http-01" validation
  Normal  IssueCert       10m   cert-manager  Issuing certificate...
  Normal  CertObtained    10m   cert-manager  Obtained certificate from ACME server
  Normal  CertIssued      10m   cert-manager  Certificate issued successfully

Testa ingresskonfigurationen

Öppna en webbläsare till FQDN för kubernetes-indatakontrollanten, till exempel https://demo-aks-ingress.eastus.cloudapp.azure.com .

Eftersom de här letsencrypt-staging exemplen använder är det utfärdade TLS/SSL-certifikatet inte betrott av webbläsaren. Acceptera varningen för att fortsätta till ditt program. Certifikatinformationen visar att detta falska LE Intermediate X1-certifikat har utfärdats av Let's Encrypt. Det här falska certifikatet cert-manager anger att begäran har bearbetats korrekt och tagit emot ett certifikat från providern:

När du ändrar Let's Encrypt till att använda i stället för används ett betrott certifikat som utfärdats av prod staging Let's Encrypt, enligt följande exempel:

Demoprogrammet visas i webbläsaren:

Lägg nu till sökvägen /hello-world-two till FQDN, till exempel https://demo-aks-ingress.eastus.cloudapp.azure.com/hello-world-two . 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 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. Ta först bort certifikatresurserna:

kubectl delete -f certificates.yaml
kubectl delete -f cluster-issuer.yaml

Visa en lista över Helm-versionerna med helm list kommandot . Leta efter diagram med namnet nginx-ingress och cert-manager enligt följande exempelutdata:

$ helm list --all-namespaces

NAME                    NAMESPACE       REVISION        UPDATED                        STATUS          CHART                   APP VERSION
nginx-ingress           ingress-basic   1               2020-01-11 14:51:03.454165006  deployed        nginx-ingress-1.28.2    0.26.2
cert-manager            ingress-basic   1               2020-01-06 21:19:03.866212286  deployed        cert-manager-v0.13.0    v0.13.0

Avinstallera versionerna med helm uninstall kommandot . I följande exempel avinstalleras NGINX-ingressdistributionen och certifikathanterarens distributioner.

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

release "nginx-ingress" deleted
release "cert-manager" deleted

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 själva namnområdet. Använd kommandot kubectl delete och ange namnet på namnområdet:

kubectl delete namespace ingress-basic

Slutligen tar du bort den statiska offentliga IP-adressen som skapades för ingress-kontrollanten. Ange namnet MC_ klusterresursgruppen som du fick i det första steget i den här artikeln, till exempel MC_myResourceGroup_myAKSCluster_eastus:

az network public-ip delete --resource-group MC_myResourceGroup_myAKSCluster_eastus --name myAKSPublicIP

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:

• Helm CLI
• NGINX-inresskontrollant
• cert-manager

Du kan även:

• Skapa en grundläggande ingress-kontrollant med extern nätverksanslutning
• Aktivera tillägget för HTTP-programroutning
• Skapa en ingress-kontrollant som använder ett internt, privat nätverk och en IP-adress
• Skapa en ingress-kontrollant som använder dina egna TLS-certifikat
• Skapa en ingresskontrollant med en dynamisk offentlig IP-adress och konfigurera Let's Encrypt för att automatiskt generera TLS-certifikat