Configurar o controlador de entrada NGINX para dar suporte à zona DNS privada do Azure com complemento de roteamento de aplicativo

Artigo
11/22/2024

Este artigo demonstra como configurar um controlador de entrada NGINX para trabalhar com o balanceador de carga interno do Azure e configurar uma zona DNS privada do Azure para habilitar a resolução DNS para os pontos de extremidade privados para resolver domínios específicos.

Antes de começar

Um cluster AKS com o complemento de roteamento de aplicativos.
Para anexar uma Zona DNS privada do Azure, você precisa da função Proprietário, administrador da conta do Azure ou coadministrador do Azure em sua assinatura do Azure.

Conecte-se ao cluster AKS

Para se conectar ao cluster do Kubernetes a partir do computador local, use kubectlo cliente de linha de comando do Kubernetes. Você pode instalá-lo localmente usando o comando az aks install-cli . Se utilizar o Azure Cloud Shell, o kubectl já está instalado.

O exemplo a seguir configura a conexão com seu cluster chamado myAKSCluster no myResourceGroup usando o az aks get-credentials comando.

az aks get-credentials --resource-group myResourceGroup --name myAKSCluster

Criar uma rede virtual

Para publicar uma zona DNS privada em sua rede virtual, você precisa especificar uma lista de redes virtuais que têm permissão para resolver registros dentro da zona. Estes são chamados links de rede virtual.

O exemplo a seguir cria uma rede virtual chamada myAzureVNet no grupo de recursos myResourceGroup e uma sub-rede chamada mySubnet para criar dentro da VNet com um prefixo de endereço específico.

az network vnet create \
  --name myAzureVNet \
  --resource-group myResourceGroup \
  --location eastus \
  --address-prefix 10.2.0.0/16 \
  --subnet-name mysubnet \
  --subnet-prefixes 10.2.0.0/24

Criar uma zona DNS privada do Azure

Nota

Você pode configurar o complemento de roteamento de aplicativo para criar automaticamente registros em uma ou mais zonas DNS globais e privadas do Azure para hosts definidos em recursos de Ingresso. Todas as zonas DNS globais do Azure e todas as zonas DNS privadas do Azure precisam estar no mesmo grupo de recursos.

Você cria uma zona DNS usando o comando az network private-dns zone create , especificando o nome da zona e o grupo de recursos no qual criá-la. O exemplo a seguir cria uma zona DNS chamada private.contoso.com no grupo de recursos myResourceGroup .

az network private-dns zone create --resource-group myResourceGroup --name private.contoso.com

Você cria um link de rede virtual para a zona DNS criada anteriormente usando o comando az network private-dns link vnet create . O exemplo a seguir cria um link chamado myDNSLink para o private.contoso.com de zona para a rede virtual myAzureVNet. Inclua o --registration-enabled parâmetro para especificar que o link não está habilitado para registro.

az network private-dns link vnet create --resource-group myResourceGroup \
  --name myDNSLink \
  --zone-name private.contoso.com \
  --virtual-network myAzureVNet \
  --registration-enabled false

O recurso de registro automático de zona privada do DNS do Azure gerencia registros DNS para máquinas virtuais implantadas em uma rede virtual. Quando você vincula uma rede virtual a uma zona DNS privada com essa configuração habilitada, um registro DNS é criado para cada máquina virtual do Azure para seu nó AKS implantado na rede virtual.

Anexar uma zona DNS privada do Azure ao complemento de roteamento de aplicativo

Nota

O az aks approuting zone add comando usa as permissões do usuário que executa o comando para criar a atribuição de função de Zona DNS do Azure. A função de Colaborador da Zona DNS Privada é uma função interna para gerenciar recursos DNS privados e é atribuída à identidade gerenciada do complemento. Para obter mais informações sobre identidades gerenciadas pelo AKS, consulte Resumo de identidades gerenciadas.

Recupere o ID do recurso para a zona DNS usando o az network dns zone show comando e defina a saída como uma variável chamada ZONEID. O exemplo a seguir consulta a zona private.contoso.com no grupo de recursos myResourceGroup.
```
ZONEID=$(az network private-dns zone show --resource-group myResourceGroup --name private.contoso.com --query "id" --output tsv)
```
Atualize o complemento para habilitar a integração com o DNS do Azure usando o az aks approuting zone comando. Você pode passar uma lista separada por vírgulas de IDs de recursos de zona DNS. O exemplo a seguir atualiza o cluster AKS myAKSCluster no grupo de recursos myResourceGroup.
```
az aks approuting zone add --resource-group myResourceGroup --name myAKSCluster --ids=${ZONEID} --attach-zones
```

Crie um controlador de entrada NGINX com um endereço IP privado e um balanceador de carga interno

O complemento de roteamento de aplicativo usa uma definição de recurso personalizada (CRD) do Kubernetes chamada NginxIngressController para configurar controladores de entrada NGINX. Você pode criar mais controladores de entrada ou modificar uma configuração existente.

NginxIngressController O CRD tem um loadBalancerAnnotations campo para controlar o comportamento do serviço do controlador de ingresso NGINX definindo anotações do balanceador de carga.

Execute as etapas a seguir para criar um controlador de entrada NGINX com um Balanceador de Carga do Azure interno com um endereço IP privado.

Copie o seguinte manifesto YAML em um novo arquivo chamado nginx-internal-controller.yaml e salve o arquivo em seu computador local.

apiVersion: approuting.kubernetes.azure.com/v1alpha1
kind: NginxIngressController
metadata:
  name: nginx-internal
spec:
  ingressClassName: nginx-internal
  controllerNamePrefix: nginx-internal
  loadBalancerAnnotations: 
    service.beta.kubernetes.io/azure-load-balancer-internal: "true"

Crie os recursos do controlador de ingresso NGINX usando o kubectl apply comando.
```
kubectl apply -f nginx-internal-controller.yaml
```
O exemplo de saída a seguir mostra o recurso criado:
```
nginxingresscontroller.approuting.kubernetes.azure.com/nginx-internal created
```

Verifique se o controlador de entrada foi criado

Você pode verificar o status do controlador de entrada NGINX usando o kubectl get nginxingresscontroller comando.

kubectl get nginxingresscontroller

A saída de exemplo a seguir mostra o recurso criado. Pode levar alguns minutos para que o controlador esteja disponível:

NAME             INGRESSCLASS                         CONTROLLERNAMEPREFIX   AVAILABLE
default          webapprouting.kubernetes.azure.com   nginx                  True
nginx-internal   nginx-internal                       nginx-internal         True

Implementar uma aplicação

O complemento de roteamento de aplicativo usa anotações em objetos Kubernetes Ingress para criar os recursos apropriados.

Crie um namespace de aplicativo chamado hello-web-app-routing para executar os pods de exemplo usando o kubectl create namespace comando.
```
kubectl create namespace hello-web-app-routing
```

Crie a implantação copiando o seguinte manifesto YAML em um novo arquivo chamado deployment.yaml e salve o arquivo em seu computador local.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: aks-helloworld  
  namespace: hello-web-app-routing
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)"

Crie o serviço copiando o seguinte manifesto YAML em um novo arquivo chamado service.yaml e salve o arquivo em seu computador local.

apiVersion: v1
kind: Service
metadata:
  name: aks-helloworld
  namespace: hello-web-app-routing
spec:
  type: ClusterIP
  ports:
  - port: 80
  selector:
    app: aks-helloworld

Crie os recursos de cluster usando o kubectl apply comando.

kubectl apply -f deployment.yaml -n hello-web-app-routing

O exemplo de saída a seguir mostra o recurso criado:

deployment.apps/aks-helloworld created created

kubectl apply -f service.yaml -n hello-web-app-routing

O exemplo de saída a seguir mostra o recurso criado:

service/aks-helloworld created created

Criar o recurso de Ingresso que usa um nome de host na zona DNS privada do Azure e um endereço IP privado

Copie o seguinte manifesto YAML em um novo arquivo chamado ingress.yaml e salve o arquivo em seu computador local.

Atualize <Hostname> com o nome do seu host DNS, por exemplo, helloworld.private.contoso.com. Verifique se você está especificando nginx-internal para o ingressClassName.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: aks-helloworld
  namespace: hello-web-app-routing
spec:
  ingressClassName: nginx-internal
  rules:
  - host: <Hostname>
    http:
      paths:
      - backend:
          service:
            name: aks-helloworld
            port:
              number: 80
        path: /
        pathType: Prefix

Crie os recursos de cluster usando o kubectl apply comando.
```
kubectl apply -f ingress.yaml -n hello-web-app-routing
```
O exemplo de saída a seguir mostra o recurso criado:
```
ingress.networking.k8s.io/aks-helloworld created
```

Verifique se o Ingress gerenciado foi criado

Você pode verificar se o Ingress gerenciado foi criado usando o kubectl get ingress comando.

kubectl get ingress -n hello-web-app-routing

A saída de exemplo a seguir mostra o Ingresso gerenciado criado:

NAME             CLASS            HOSTS                            ADDRESS      PORTS   AGE
aks-helloworld   nginx-internal   helloworld.private.contoso.com   10.224.0.7   80      98s

Verifique se a zona DNS privada do Azure foi atualizada

Em poucos minutos, execute o comando az network private-dns record-set a list para exibir os registros A para sua zona DNS privada do Azure. Especifique o nome do grupo de recursos e o nome da zona DNS. Neste exemplo, o grupo de recursos é myResourceGroup e a zona DNS é private.contoso.com.

az network private-dns record-set a list --resource-group myResourceGroup --zone-name private.contoso.com

A saída de exemplo a seguir mostra o registro criado:

[
  {
    "aRecords": [
      {
        "ipv4Address": "10.224.0.7"
      }
    ],
    "etag": "188f0ce5-90e3-49e6-a479-9e4053f21965",
    "fqdn": "helloworld.private.contoso.com.",
    "id": "/subscriptions/xxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxx/resourceGroups/foo/providers/Microsoft.Network/privateDnsZones/private.contoso.com/A/helloworld",
    "isAutoRegistered": false,
    "name": "helloworld",
    "resourceGroup": "foo",
    "ttl": 300,
    "type": "Microsoft.Network/privateDnsZones/A"
  }
]

Próximos passos

Para obter outras informações de configuração relacionadas à criptografia SSL, outro controlador de entrada NGINX avançado e configuração de recursos de entrada, revise a configuração de DNS e SSL e a configuração de complementos de roteamento de aplicativos.

Partilhar via