Vytvoření kontroleru příchozího přenosu dat HTTPS Azure Kubernetes Service (AKS)

  • Článek
  • 14 min ke čtení

Kontroler příchozích dat je software, který poskytuje reverzní proxy server, konfigurovatelné směrování provozu a ukončení protokolu TLS pro služby Kubernetes. Prostředky příchozího přenosu dat Kubernetes se používají ke konfiguraci pravidel příchozího přenosu dat a tras pro jednotlivé služby Kubernetes. Pomocí kontroleru příchozího přenosu dat a pravidel příchozího přenosu dat je možné jednu IP adresu použít ke směrování provozu do několika služeb v clusteru Kubernetes.

Tento článek ukazuje, jak nasadit kontroler příchozího přenosu dat NGINX v clusteru Azure Kubernetes Service (AKS). Projekt cert-manager slouží k automatickému generování a konfiguraci certifikátů Let's Encrypt. Nakonec se v clusteru AKS spustí dvě aplikace, z nichž každá je přístupná přes jednu IP adresu.

Můžete také:

Než začnete

Tento článek předpokládá, že máte existující cluster AKS. Pokud potřebujete cluster AKS, prohlédněte si rychlý start pro AKS s využitím Azure CLI Azure PowerShell nebo s využitím Azure Portal.

Tento článek také předpokládá, že máte vlastní doménu se zónou DNS ve stejné skupině prostředků jako cluster AKS.

Tento článek používá Helm 3 k instalaci kontroleru příchozího přenosu dat NGINX na podporovanou verzi Kubernetes. Ujistěte se, že používáte nejnovější verzi Helmu a že máte přístup k ingress-nginx úložišti jetstack a Helm. Kroky popsané v tomto článku nemusí být kompatibilní s předchozími verzemi chartu Helm, kontroleru příchozího přenosu dat NGINX nebo Kubernetes.

Další informace o konfiguraci a používání Nástroje Helm najdete v tématu Instalace aplikací pomocí nástroje Helm v Azure Kubernetes Service (AKS). Pokyny k upgradu najdete v tématu Dokumentace k instalaci Helmu.

Kromě toho tento článek předpokládá, že máte existující cluster AKS s integrovaným ACR. Další podrobnosti o vytvoření clusteru AKS s integrovaným ACR najdete v tématu Ověřování pomocí Azure Container Registry z Azure Kubernetes Service.

Tento článek také vyžaduje použití Azure CLI verze 2.0.64 nebo novější. Verzi zjistíte spuštěním příkazu az --version. Pokud potřebujete instalaci nebo upgrade, přečtěte si téma Instalace Azure CLI.

Import imagí používaných chartem Helm do ACR

Tento článek používá chart Helm kontroleru příchozího přenosu dat NGINX,který spoléhá na tři image kontejneru.

Pomocí az acr import naimportujte tyto image do 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
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 $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
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

Poznámka

Kromě importu imagí kontejnerů do ACR můžete do ACR importovat také grafy Helm. Další informace najdete v tématu Nabízení a stažení grafů Helm do registru kontejneru Azure.

Vytvoření kontroleru příchozího přenosu dat

K vytvoření kontroleru příchozího přenosu dat helm použijte příkaz k instalaci nginx-ingress. Pro přidání redundance se nasadí dvě repliky kontrolerů příchozího přenosu dat NGINX s parametrem --set controller.replicaCount. Pokud chcete plně využít výhod spouštění replik kontroleru příchozího přenosu dat, ujistěte se, že je v clusteru AKS více než jeden uzel.

Kontroler příchozího přenosu dat je potřeba naplánovat také v uzlu Linuxu. V uzlech Windows Serveru by se kontroler příchozího přenosu dat neměl spouštět. Selektor uzlů se specifikuje pomocí parametru --set nodeSelector, aby plánovači Kubernetes oznámil, že má spustit kontroler příchozího přenosu dat NGINX v uzlu Linuxu.

Tip

Následující příklad vytvoří obor názvů Kubernetes pro prostředky příchozího přenosu dat s názvem ingress-basic a je určený k práci v tomto oboru názvů. Podle potřeby zadejte obor názvů pro vlastní prostředí.

Tip

Pokud chcete pro požadavky na kontejnery v clusteru povolit zachování zdrojové IP adresy klienta, přidejte do příkazu Helm --set controller.service.externalTrafficPolicy=Local install . Zdrojová IP adresa klienta je uložená v hlavičce požadavku v části X-Forwarded-For. Při použití kontroleru příchozího přenosu dat s povolenou zachováním zdrojové IP adresy klienta nebude průchod TLS fungovat.

# 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=""

Během instalace se vytvoří veřejná IP adresa Azure pro kontroler příchozího přenosu dat. Tato veřejná IP adresa je statická po dobu životnosti kontroleru příchozího přenosu dat. Pokud odstraníte kontroler příchozího přenosu dat, přiřazení veřejné IP adresy se ztratí. Pokud pak vytvoříte další kontroler příchozího přenosu dat, přiřadí se nová veřejná IP adresa. Pokud chcete zachovat použití veřejné IP adresy, můžete místo toho vytvořit kontroler příchozího přenosu dat se statickou veřejnou IP adresou.

Veřejnou IP adresu získáte pomocí kubectl get service příkazu . Přiřazení IP adresy ke službě trvá několik minut.

$ 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

Zatím nebyla vytvořena žádná pravidla příchozího přenosu dat. Pokud vyhledáte veřejnou IP adresu, zobrazí se výchozí stránka 404 kontroleru příchozího přenosu dat NGINX.

Přidání záznamu A do zóny DNS

Pomocí příkazu az network dns record-set a add-recordpřidejte do zóny DNS záznam A s externí IP adresou služby NGINX.

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

Konfigurace plně kvalifikovaných názvu domény pro kontroler příchozího přenosu dat

Volitelně můžete místo vlastní domény nakonfigurovat plně kvalifikovaný název domény pro IP adresu řadiče příchozího přenosu dat. Plně kvalifikovaný název domény bude ve formátu <CUSTOM LABEL>.<AZURE REGION NAME>.cloudapp.azure.com .

Pro tuto konfiguraci jsou popsané dvě metody:

Metoda 1: Nastavení popisku DNS pomocí Azure CLI

Všimněte si, že tato ukázka je pro prostředí Bash.

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

# Name to associate with public IP address
DNSNAME="demo-aks-ingress"

# 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 $DNSNAME

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

Metoda 2: Nastavení popisku DNS pomocí nastavení chartu Helm

Nastavení poznámek můžete předat konfiguraci chartu Helm pomocí --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-dns-label-name" parametru . To se může nastavit buď při prvním nasazení kontroleru příchozího přenosu dat, nebo při jeho konfiguraci později. Následující příklad ukazuje, jak toto nastavení aktualizovat po nasazení kontroleru.

DNS_LABEL="demo-aks-ingress"
NAMESPACE="nginx-basic"

helm upgrade ingress-nginx ingress-nginx/ingress-nginx \
  --namespace $NAMESPACE \
  --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-dns-label-name"=$DNS_LABEL

Instalace nástroje cert-manager

Kontroler příchozího přenosu dat NGINX podporuje ukončení protokolu TLS. Existuje několik způsobů, jak načíst a nakonfigurovat certifikáty pro protokol HTTPS. Tento článek ukazuje použití nástroje cert-manager,který poskytuje automatické generování a správu certifikátů Lets Encrypt.

Instalace kontroleru cert-manager:

# 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

Další informace o konfiguraci nástroje cert-manager najdete v projektu cert-manager.

Vytvoření vystavitele clusteru certifikační autority

Před vydáním certifikátů vyžaduje nástroj cert-manager prostředek Vystavitel nebo ClusterIssuer. Tyto prostředky Kubernetes mají stejné funkce, ale fungují v jednom oboru názvů Issuer a fungují ve všech ClusterIssuer oborech názvů. Další informace najdete v dokumentaci vystavitele nástroje cert-manager.

Pomocí následujícího příkladu manifestu vytvořte cluster-issuer.yaml vystavitele clusteru, například . Aktualizujte e-mailovou adresu platnou adresou z vaší organizace:

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

Vystavitele vytvoříte pomocí kubectl apply příkazu .

kubectl apply -f cluster-issuer.yaml

Spouštění ukázkových aplikací

Nakonfigurovali jste kontroler příchozího přenosu dat a řešení správy certifikátů. Teď v clusteru AKS spustíme dvě ukázkové aplikace. V tomto příkladu se Helm používá k nasazení dvou instancí jednoduché aplikace Hello World.

Pokud chcete zobrazit kontroler příchozího přenosu dat v akci, spusťte v clusteru AKS dvě ukázkové aplikace. V tomto příkladu použijete k nasazení dvou instancí jednoduché kubectl apply aplikace Hello World.

Vytvořte soubor aks-helloworld-one.yaml a zkopírujte ho v následujícím příkladu YAML:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: aks-helloworld-one
spec:
  replicas: 1
  selector:
    matchLabels:
      app: aks-helloworld-one
  template:
    metadata:
      labels:
        app: aks-helloworld-one
    spec:
      containers:
      - name: aks-helloworld-one
        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-one
spec:
  type: ClusterIP
  ports:
  - port: 80
  selector:
    app: aks-helloworld-one

Vytvořte soubor aks-helloworld-two.yaml a zkopírujte ho v následujícím příkladu YAML:

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

Spusťte dvě ukázkové aplikace pomocí kubectl apply příkazu :

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

Vytvoření trasy příchozího přenosu dat

Obě aplikace jsou teď spuštěné v clusteru Kubernetes. Jsou ale nakonfigurované pomocí služby typu a nejsou přístupné ClusterIP z internetu. Pokud je chcete veřejně používat, vytvořte prostředek příchozího přenosu dat Kubernetes. Prostředek příchozího přenosu dat nakonfiguruje pravidla, která směruje provoz do jedné ze dvou aplikací.

V následujícím příkladu se provoz na adresu hello-world-ingress. MY_CUSTOM_DOMAIN se směruje do služby aks-helloworld-one. Provoz na adresu hello-world-ingress. MY_CUSTOM_DOMAIN/hello-world-two je směrován do služby aks-helloworld-two. Provoz do příchozího přenosu dat hello-world. MY_CUSTOM_DOMAIN/static se pro statické prostředky směruje do služby s názvem aks-helloworld-one.

Poznámka

Pokud jste nakonfigurovali plně kvalifikovaný název domény pro IP adresu řadiče příchozího přenosu dat místo vlastní domény, použijte plně kvalifikovaný název domény místo hello-world-ingress. MY_CUSTOM_DOMAIN. Pokud je například plně kvalifikovaný název domény demo-aks-ingress.eastus.cloudapp.azure.com , nahraďte hello-world-ingress. MY_CUSTOM_DOMAIN s demo-aks-ingress.eastus.cloudapp.azure.com v hello-world-ingress.yaml .

Vytvořte soubor s názvem hello-world-ingress.yaml pomocí následujícího příkladu YAML. Aktualizujte hostitele a hostitele na název DNS, který jste vytvořili v předchozím kroku.

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

Pomocí příkazu vytvořte prostředek příchozího kubectl apply přenosu dat.

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

Ověření vytvoření objektu certifikátu

Dále je nutné vytvořit prostředek certifikátu. Prostředek certifikátu definuje požadovaný certifikát X.509. Další informace najdete v tématu certifikáty nástroje cert-manager. Nástroj Cert-manager pro vás automaticky vytvořil objekt certifikátu pomocí ingress-shim, který se automaticky nasazovat pomocí nástroje cert-manager od v0.2.2. Další informace najdete v dokumentaci k ingress-shim.

Pokud chcete ověřit úspěšné vytvoření certifikátu, použijte příkaz a ověřte, že kubectl get certificate --namespace ingress-basic je připraveno na hodnotu True, což může trvat několik minut.

$ kubectl get certificate --namespace ingress-basic

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

Testování konfigurace příchozího přenosu dat

Otevřete webový prohlížeč s příchozím přenosem dat hello-world-ingress. MY_CUSTOM_DOMAIN kontroleru příchozího přenosu dat Kubernetes. Všimněte si, že jste přesměrováni na použití protokolu HTTPS a certifikát je důvěryhodný a ukázková aplikace se zobrazí ve webovém prohlížeči. Přidejte cestu /hello-world-two a všimněte si, že se zobrazí druhá ukázková aplikace s vlastním názvem.

Vyčištění prostředků

Tento článek používal Helm k instalaci komponent příchozího přenosu dat, certifikátů a ukázkových aplikací. Když nasadíte chart Helm, vytvoří se několik prostředků Kubernetes. Tyto prostředky zahrnují pody, nasazení a služby. Pokud chcete tyto prostředky vyčistit, můžete odstranit celý ukázkový obor názvů nebo jednotlivé prostředky.

Odstranění ukázkového oboru názvů a všech prostředků

Pokud chcete odstranit celý ukázkový obor názvů, použijte kubectl delete příkaz a zadejte název oboru názvů. Odstraní se všechny prostředky v oboru názvů .

kubectl delete namespace ingress-basic

Odstranění prostředků jednotlivě

Případně je podrobnějším přístupem odstranění jednotlivých vytvořených prostředků. Nejprve odeberte prostředky vystavitele clusteru:

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

Vy list the Helm releases with the command (Vy listovat verze Helmu) helm list pomocí příkazu . Vyhledejte grafy s názvem nginx a cert-manager, jak je znázorněno v následujícím příkladu výstupu:

$ 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

Odinstalujte verze pomocí helm uninstall příkazu . Následující příklad odinstaluje nasazení příchozího přenosu dat NGINX a nástroje cert-manager.

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

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

Dále odeberte dvě ukázkové aplikace:

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

Odeberte trasu příchozího přenosu dat, která směrovala provoz do ukázkových aplikací:

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

Nakonec můžete odstranit samotný obor názvů. Použijte příkaz kubectl delete a zadejte název oboru názvů:

kubectl delete namespace ingress-basic

Další kroky

Tento článek obsahuje některé externí komponenty pro AKS. Další informace o těchto komponentách najdete na následujících stránkách projektu:

Můžete také: