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

  • Článek

Kontroler příchozího přenosu 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 a tras pro příchozí data u jednotlivých služeb Kubernetes. Když používáte kontroler příchozího přenosu dat a pravidla příchozího přenosu dat, můžete ke směrování provozu na více služeb v clusteru Kubernetes použít jedinou IP adresu.

V tomto článku se dozvíte, jak nasadit kontroler příchozího přenosu dat NGINX v clusteru Azure Kubernetes Service (AKS). V clusteru AKS se pak spustí dvě aplikace, z nichž každá je přístupná přes jednu IP adresu.

Důležité

Doplněk Směrování aplikací se doporučuje pro příchozí přenos dat v AKS. Další informace najdete v tématu Spravované příchozí přenosy dat nginx s doplňkem směrování aplikace.

Poznámka:

Existují dva kontrolery příchozího přenosu dat open source pro Kubernetes založené na Nginx: jeden spravuje komunita Kubernetes (kubernetes/ingress-nginx) a jeden spravuje NGINX, Inc. (nginxinc/kubernetes-ingress). Tento článek bude používat kontroler příchozího přenosu dat komunity Kubernetes.

Než začnete

  • Tento článek používá Helm 3 k instalaci kontroleru příchozího přenosu dat NGINX do podporované verze Kubernetes. Ujistěte se, že používáte nejnovější verzi Helmu a máte přístup k úložišti ingress-nginx Helm. Kroky popsané v tomto článku nemusí být kompatibilní s předchozími verzemi chartu Helm, kontrolerem příchozího přenosu dat NGINX nebo Kubernetes.
  • Tento článek předpokládá, že máte existující cluster AKS s integrovanou službou Azure Container Registry (ACR). Další informace o vytvoření clusteru AKS s integrovaným ACR najdete v tématu Ověřování pomocí služby Azure Container Registry ze služby Azure Kubernetes Service.
  • Koncový bod healthz stavu rozhraní API Kubernetes byl v Kubernetes verze 1.16 zastaralý. Tento koncový bod livezreadyz můžete místo toho nahradit koncovými body. Informace o stavu koncových bodů rozhraní API Kubernetes najdete v tématu Určení koncového bodu, který se má použít pro váš scénář.
  • Pokud používáte Azure CLI, musíte mít 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.
  • Pokud používáte Azure PowerShell, musíte mít Azure PowerShell verze 5.9.0 nebo novější. Verzi zjistíte spuštěním příkazu Get-InstalledModule -Name Az. Pokud potřebujete provést instalaci nebo upgrade, přečtěte si téma Instalace Azure PowerShellu.

Základní konfigurace

Pokud chcete vytvořit základní kontroler příchozího přenosu dat NGINX bez přizpůsobení výchozích hodnot, použijete Helm. Následující konfigurace pro zjednodušení používá výchozí konfiguraci. Můžete přidat parametry pro přizpůsobení nasazení, například --set controller.replicaCount=3.

Poznámka:

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

NAMESPACE=ingress-basic

helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update

helm install ingress-nginx ingress-nginx/ingress-nginx \
  --create-namespace \
  --namespace $NAMESPACE \
  --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-load-balancer-health-probe-request-path"=/healthz \
  --set controller.service.externalTrafficPolicy=Local

Poznámka:

V tomto kurzu service.beta.kubernetes.io/azure-load-balancer-health-probe-request-path je nastavena na /healthz. To znamená, že pokud kód odpovědi požadavků /healthz není 200, celý kontroler příchozího přenosu dat bude dolů. Hodnotu můžete upravit na jiný identifikátor URI ve vašem vlastním scénáři. Tuto část nelze odstranit nebo zrušit její hodnotu nebo kontroler příchozího přenosu dat bude stále dole. Balíček ingress-nginx použitý v tomto kurzu, který poskytuje oficiální kubernetes, vždy vrátí 200 kód odpovědi, pokud požaduje /healthz, protože je navržen jako výchozí back-end pro uživatele, aby měli rychlý start, pokud je přepsána pravidly příchozího přenosu dat.

Přizpůsobená konfigurace

Jako alternativu k základní konfiguraci uvedené v předchozí části se v další sadě kroků dozvíte, jak nasadit přizpůsobený kontroler příchozího přenosu dat. Budete mít možnost použít interní statickou IP adresu nebo dynamickou veřejnou IP adresu.

Import obrázků používaných chartem Helm do služby ACR

Pokud chcete řídit verze imagí, budete je chtít importovat do vlastní služby Azure Container Registry. Chart Helm kontroleru příchozího přenosu dat NGINX spoléhá na tři image kontejnerů. Slouží az acr import k importu těchto imagí do služby ACR.

REGISTRY_NAME=<REGISTRY_NAME>
SOURCE_REGISTRY=registry.k8s.io
CONTROLLER_IMAGE=ingress-nginx/controller
CONTROLLER_TAG=v1.8.1
PATCH_IMAGE=ingress-nginx/kube-webhook-certgen
PATCH_TAG=v20230407
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

Poznámka:

Kromě importu imagí kontejnerů do služby ACR můžete do služby ACR také importovat charty Helm. Další informace najdete v tématu Vložení a vyžádání chartů Helm do služby Azure Container Registry.

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

K vytvoření kontroleru příchozího přenosu dat použijte Helm k instalaci ingress-nginx. Kontroler příchozího přenosu dat je potřeba naplánovat na linuxovém uzlu. 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.

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.

Následující příklad vytvoří obor názvů Kubernetes pro prostředky příchozího přenosu dat pojmenované ingress-basic a je určen pro práci v rámci tohoto oboru názvů. Podle potřeby zadejte obor názvů pro vaše vlastní prostředí. Pokud váš cluster AKS není povolený řízení přístupu na základě role Kubernetes, přidejte --set rbac.create=false je do příkazů Helm.

Poznámka:

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

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

# Set variable for ACR location to use for pulling images
ACR_LOGIN_SERVER=<REGISTRY_LOGIN_SERVER>

# Use Helm to deploy an NGINX ingress controller
helm install ingress-nginx ingress-nginx/ingress-nginx \
    --version 4.7.1 \
    --namespace ingress-basic \
    --create-namespace \
    --set controller.replicaCount=2 \
    --set controller.nodeSelector."kubernetes\.io/os"=linux \
    --set controller.image.registry=$ACR_LOGIN_SERVER \
    --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.service.annotations."service\.beta\.kubernetes\.io/azure-load-balancer-health-probe-request-path"=/healthz \
    --set controller.service.externalTrafficPolicy=Local \
    --set controller.admissionWebhooks.patch.image.registry=$ACR_LOGIN_SERVER \
    --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_LOGIN_SERVER \
    --set defaultBackend.image.image=$DEFAULTBACKEND_IMAGE \
    --set defaultBackend.image.tag=$DEFAULTBACKEND_TAG \
    --set defaultBackend.image.digest=""

Vytvoření kontroleru příchozího přenosu dat pomocí interní IP adresy

Ve výchozím nastavení se vytvoří kontroler příchozího přenosu dat NGINX s dynamickým přiřazením veřejné IP adresy. Běžným požadavkem na konfiguraci je použití interní, privátní sítě a IP adresy. Tento přístup umožňuje omezit přístup ke službám interním uživatelům bez externího přístupu.

--set controller.service.loadBalancerIP Pomocí parametrů přiřaďte --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-load-balancer-internal"=true interní IP adresu kontroleru příchozího přenosu dat. Zadejte vlastní interní IP adresu pro použití s kontrolerem příchozího přenosu dat. Ujistěte se, že se tato IP adresa ještě nepoužívá ve vaší virtuální síti. Pokud používáte existující virtuální síť a podsíť, musíte cluster AKS nakonfigurovat se správnými oprávněními ke správě virtuální sítě a podsítě. Další informace najdete v tématu Použití sítě kubenet s vlastními rozsahy IP adres ve službě Azure Kubernetes Service (AKS) nebo konfigurace sítí Azure CNI ve službě Azure Kubernetes Service (AKS).

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

# Set variable for ACR location to use for pulling images
ACR_LOGIN_SERVER=<REGISTRY_LOGIN_SERVER>

# Use Helm to deploy an NGINX ingress controller
helm install ingress-nginx ingress-nginx/ingress-nginx \
    --version 4.7.1 \
    --namespace ingress-basic \
    --create-namespace \
    --set controller.replicaCount=2 \
    --set controller.nodeSelector."kubernetes\.io/os"=linux \
    --set controller.image.registry=$ACR_LOGIN_SERVER \
    --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.service.loadBalancerIP=10.224.0.42 \
    --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-load-balancer-internal"=true \
    --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-load-balancer-health-probe-request-path"=/healthz \
    --set controller.admissionWebhooks.patch.image.registry=$ACR_LOGIN_SERVER \
    --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_LOGIN_SERVER \
    --set defaultBackend.image.image=$DEFAULTBACKEND_IMAGE \
    --set defaultBackend.image.tag=$DEFAULTBACKEND_TAG \
    --set defaultBackend.image.digest=""

Kontrola služby nástroje pro vyrovnávání zatížení

Pomocí nástroje kubectl get servicespro vyrovnávání zatížení zkontrolujte službu nástroje pro vyrovnávání zatížení.

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

Když se pro kontroler příchozího přenosu dat NGINX vytvoří služba nástroje pro vyrovnávání zatížení Kubernetes, přiřadí se IP adresa v rámci EXTERNÍ IP adresy, jak je znázorněno v následujícím příkladu výstupu:

NAME                       TYPE           CLUSTER-IP    EXTERNAL-IP     PORT(S)                      AGE   SELECTOR
ingress-nginx-controller   LoadBalancer   10.0.65.205   EXTERNAL-IP     80:30957/TCP,443:32414/TCP   1m   app.kubernetes.io/component=controller,app.kubernetes.io/instance=ingress-nginx,app.kubernetes.io/name=ingress-nginx

Pokud v této fázi přejdete na externí IP adresu, zobrazí se stránka 404. Je to proto, že stále potřebujete nastavit připojení k externí IP adrese, která se provádí v dalších částech.

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

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

  1. Vytvořte aks-helloworld-one.yaml soubor 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

  2. Vytvořte aks-helloworld-two.yaml soubor 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

  3. Spusťte dvě ukázkové aplikace pomocí kubectl apply:

    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. Pokud chcete směrovat provoz do každé aplikace, vytvořte prostředek příchozího přenosu dat Kubernetes. Prostředek příchozího přenosu dat konfiguruje pravidla, která směrují provoz do jedné ze dvou aplikací.

V následujícím příkladu se provoz do EXTERNAL_IP/hello-world-one směruje do služby s názvem aks-helloworld-one. Provoz do služby EXTERNAL_IP/hello-world-two se směruje do aks-helloworld-two služby. Provoz do EXTERNAL_IP/static se směruje do služby pojmenované aks-helloworld-one pro statické prostředky.

  1. Vytvořte soubor s názvem hello-world-ingress.yaml a zkopírujte ho v následujícím příkladu YAML:

    apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: hello-world-ingress
  annotations:
    nginx.ingress.kubernetes.io/ssl-redirect: "false"
    nginx.ingress.kubernetes.io/use-regex: "true"
    nginx.ingress.kubernetes.io/rewrite-target: /$2
spec:
  ingressClassName: nginx
  rules:
  - 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
  rules:
  - http:
      paths:
      - path: /static(/|$)(.*)
        pathType: Prefix
        backend:
          service:
            name: aks-helloworld-one
            port: 
              number: 80

  2. 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

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

Pokud chcete otestovat trasy pro kontroler příchozího přenosu dat, přejděte ke dvěma aplikacím. Otevřete webový prohlížeč na IP adresu kontroleru příchozího přenosu dat NGINX, například EXTERNAL_IP. První ukázková aplikace se zobrazí ve webovém prohlížeči, jak je znázorněno v následujícím příkladu:

First app running behind the ingress controller

Teď přidejte cestu /hello-world-two k IP adrese, například EXTERNAL_IP/hello-world-two. Zobrazí se druhá ukázková aplikace s vlastním názvem:

Second app running behind the ingress controller

Testování interní IP adresy

  1. Vytvořte testovací pod a připojte k němu relaci terminálu.

    kubectl run -it --rm aks-ingress-test --image=mcr.microsoft.com/dotnet/runtime-deps:6.0 --namespace ingress-basic

  2. Nainstalujte curl do podu pomocí apt-get.

    apt-get update && apt-get install -y curl

  3. Přístup k adrese kontroleru příchozího přenosu dat Kubernetes pomocí curl, například http://10.224.0.42. Zadejte vlastní interní IP adresu zadanou při nasazení kontroleru příchozího přenosu dat.

    curl -L http://10.224.0.42

    Nebyla k dispozici žádná cesta s adresou, takže kontroler příchozího přenosu dat je výchozí pro trasu / . Vrátí se první ukázková aplikace, jak je znázorněno v následujícím zhuštěném ukázkovém výstupu:

    <!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>
[...]

  4. Přidejte k adrese /hello-world-two cestu, například http://10.224.0.42/hello-world-two.

    curl -L -k http://10.224.0.42/hello-world-two

    Vrátí se druhá ukázková aplikace s vlastním názvem, jak je znázorněno v následujícím zhuštěném příkladu výstupu:

    <!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>
[...]

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

Tento článek použil Helm k instalaci komponent příchozího přenosu dat a ukázkových aplikací. Když nasadíte chart Helm, vytvoří se mnoho prostředků Kubernetes. Mezi tyto prostředky patří 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ě

Alternativně je podrobnější přístup k odstranění jednotlivých prostředků vytvořených.

  1. Vypíše verzi Helmu pomocí helm list příkazu.

    helm list --namespace ingress-basic

    Vyhledejte grafy s názvem ingress-nginx a aks-helloworld, jak je znázorněno v následujícím příkladu výstupu:

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

  2. Odinstalujte vydané verze pomocí helm uninstall příkazu.

    helm uninstall ingress-nginx --namespace ingress-basic

  3. 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

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

    kubectl delete -f hello-world-ingress.yaml

  5. Odstraňte obor názvů pomocí kubectl delete příkazu a zadejte název oboru názvů.

    kubectl delete namespace ingress-basic

Další kroky

Pokud chcete nakonfigurovat protokol TLS se stávajícími komponentami příchozího přenosu dat, přečtěte si téma Použití protokolu TLS s kontrolerem příchozího přenosu dat.

Pokud chcete nakonfigurovat cluster AKS tak, aby používal směrování aplikace HTTP, přečtěte si téma Povolení doplňku směrování aplikace HTTP.

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