Criar um controlador de entrada HTTPS no serviço kubernetes do Azure (AKS)Create an HTTPS ingress controller on Azure Kubernetes Service (AKS)

Um controlador de entrada é uma parte do software que fornece proxy reverso, roteamento de tráfego configurável e terminação de TLS para serviços Kubernetess.An ingress controller is a piece of software that provides reverse proxy, configurable traffic routing, and TLS termination for Kubernetes services. Os recursos de entrada do kubernetes são usados para configurar as regras de entrada e rotas para serviços individuais do kubernetes.Kubernetes ingress resources are used to configure the ingress rules and routes for individual Kubernetes services. Usando um controlador de entrada e regras de entrada, um único endereço IP pode ser usado para rotear o tráfego para vários serviços em um cluster kubernetes.Using an ingress controller and ingress rules, a single IP address can be used to route traffic to multiple services in a Kubernetes cluster.

Este artigo mostra como implantar o controlador de entrada Nginx em um cluster do AKS (serviço kubernetes do Azure).This article shows you how to deploy the NGINX ingress controller in an Azure Kubernetes Service (AKS) cluster. O projeto CERT-Manager é usado para gerar e configurar automaticamente os certificados criptografados.The cert-manager project is used to automatically generate and configure Let's Encrypt certificates. Por fim, dois aplicativos são executados no cluster AKS, cada um deles acessível por um único endereço IP.Finally, two applications are run in the AKS cluster, each of which is accessible over a single IP address.

Também pode:You can also:

Antes de começarBefore you begin

Este artigo pressupõe que você tenha um cluster AKS existente.This article assumes that you have an existing AKS cluster. Se você precisar de um cluster AKS, consulte o guia de início rápido do AKS usando o CLI do Azure ou usando o portal do Azure.If you need an AKS cluster, see the AKS quickstart using the Azure CLI or using the Azure portal.

Este artigo usa o Helm para instalar o controlador de entrada do NGINX, o CERT-Manager e um aplicativo Web de exemplo.This article uses Helm to install the NGINX ingress controller, cert-manager, and a sample web app. Você precisa ter o Helm inicializado em seu cluster AKS e usar uma conta de serviço para o gaveta.You need to have Helm initialized within your AKS cluster and using a service account for Tiller. Verifique se você está usando a versão mais recente do Helm.Make sure that you are using the latest release of Helm. Para obter instruções de atualização, consulte o Helm instalar documentos. Para obter mais informações sobre como configurar e usar o Helm, consulte instalar aplicativos com Helm no serviço kubernetes do Azure (AKs).For upgrade instructions, see the Helm install docs. For more information on configuring and using Helm, see Install applications with Helm in Azure Kubernetes Service (AKS).

Este artigo também requer que você esteja executando o CLI do Azure versão 2.0.64 ou posterior.This article also requires that you are running the Azure CLI version 2.0.64 or later. Executar az --version para localizar a versão.Run az --version to find the version. Se precisar de instalar ou atualizar, veja Instalar a CLI do Azure.If you need to install or upgrade, see Install Azure CLI.

Criar um controlador de entradaCreate an ingress controller

Para criar o controlador de entrada, use Helm para instalar o Nginx-Ingres.To create the ingress controller, use Helm to install nginx-ingress. Para redundância adicional, duas réplicas dos controladores de entrada do Nginx são implantadas com --set controller.replicaCount o parâmetro.For added redundancy, two replicas of the NGINX ingress controllers are deployed with the --set controller.replicaCount parameter. Para se beneficiar totalmente da execução de réplicas do controlador de entrada, verifique se há mais de um nó no cluster AKS.To fully benefit from running replicas of the ingress controller, make sure there's more than one node in your AKS cluster.

O controlador de entrada também precisa ser agendado em um nó do Linux.The ingress controller also needs to be scheduled on a Linux node. Os nós do Windows Server (atualmente em visualização no AKS) não devem executar o controlador de entrada.Windows Server nodes (currently in preview in AKS) shouldn't run the ingress controller. Um seletor de nó é especificado --set nodeSelector usando o parâmetro para instruir o Agendador kubernetes a executar o controlador de entrada Nginx em um nó baseado em Linux.A node selector is specified using the --set nodeSelector parameter to tell the Kubernetes scheduler to run the NGINX ingress controller on a Linux-based node.

Dica

O exemplo a seguir cria um namespace kubernetes para os recursos de entrada chamados ingress-Basic.The following example creates a Kubernetes namespace for the ingress resources named ingress-basic. Especifique um namespace para seu próprio ambiente, conforme necessário.Specify a namespace for your own environment as needed. Se o cluster AKs não estiver habilitado para RBAC, --set rbac.create=false adicione aos comandos Helm.If your AKS cluster is not RBAC enabled, add --set rbac.create=false to the Helm commands.

Dica

Se você quiser habilitar a preservação de IP de origem do cliente para solicitações a contêineres em seu --set controller.service.externalTrafficPolicy=Local cluster, adicione ao comando Helm install.If you would like to enable client source IP preservation for requests to containers in your cluster, add --set controller.service.externalTrafficPolicy=Local to the Helm install command. O IP de origem do cliente é armazenado no cabeçalho da solicitação em X-forwardd-for.The client source IP is stored in the request header under X-Forwarded-For. Ao usar um controlador de entrada com preservação de IP de origem do cliente habilitada, a passagem SSL não funcionará.When using an ingress controller with client source IP preservation enabled, SSL pass-through will not work.

# Create a namespace for your ingress resources
kubectl create namespace ingress-basic

# Use Helm to deploy an NGINX ingress controller
helm install stable/nginx-ingress \
    --namespace ingress-basic \
    --set controller.replicaCount=2 \
    --set controller.nodeSelector."beta\.kubernetes\.io/os"=linux \
    --set defaultBackend.nodeSelector."beta\.kubernetes\.io/os"=linux

Durante a instalação, um endereço IP público do Azure é criado para o controlador de entrada.During the installation, an Azure public IP address is created for the ingress controller. Esse endereço IP público é estático para o período de vida útil do controlador de entrada.This public IP address is static for the life-span of the ingress controller. Se você excluir o controlador de entrada, a atribuição de endereço IP público será perdida.If you delete the ingress controller, the public IP address assignment is lost. Se você criar um controlador de entrada adicional, um novo endereço IP público será atribuído.If you then create an additional ingress controller, a new public IP address is assigned. Se você quiser manter o uso do endereço IP público, poderá criar um controlador de entrada com um endereço IP público estático.If you wish to retain the use of the public IP address, you can instead create an ingress controller with a static public IP address.

Para obter o endereço IP público, use o kubectl get service comando.To get the public IP address, use the kubectl get service command. Leva alguns minutos para que o endereço IP seja atribuído ao serviço.It takes a few minutes for the IP address to be assigned to the service.

$ kubectl get service -l app=nginx-ingress --namespace ingress-basic

NAME                                             TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)                      AGE
billowing-kitten-nginx-ingress-controller        LoadBalancer   10.0.182.160   51.145.155.210  80:30920/TCP,443:30426/TCP   20m
billowing-kitten-nginx-ingress-default-backend   ClusterIP      10.0.255.77    <none>          80/TCP                       20m

Nenhuma regra de entrada foi criada ainda.No ingress rules have been created yet. Se você navegar até o endereço IP público, a página padrão 404 do controlador de entrada do NGINX será exibida.If you browse to the public IP address, the NGINX ingress controller's default 404 page is displayed.

Configurar um nome DNSConfigure a DNS name

Para que os certificados HTTPS funcionem corretamente, configure um FQDN para o endereço IP do controlador de entrada.For the HTTPS certificates to work correctly, configure an FQDN for the ingress controller IP address. Atualize o script a seguir com o endereço IP do controlador de entrada e um nome exclusivo que você deseja usar para o FQDN:Update the following script with the IP address of your ingress controller and a unique name that you would like to use for the FQDN:

#!/bin/bash

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

# 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

O controlador de entrada agora está acessível por meio do FQDN.The ingress controller is now accessible through the FQDN.

Instalar o CERT-ManagerInstall cert-manager

O controlador de entrada NGINX dá suporte à terminação de TLS.The NGINX ingress controller supports TLS termination. Há várias maneiras de recuperar e configurar certificados para HTTPS.There are several ways to retrieve and configure certificates for HTTPS. Este artigo demonstra como usar o CERT-Manager, que fornece a funcionalidade de gerenciamento e geração de certificados automáticos.This article demonstrates using cert-manager, which provides automatic Lets Encrypt certificate generation and management functionality.

Nota

Este artigo usa o staging ambiente para criptografar.This article uses the staging environment for Let's Encrypt. Em implantações de produção letsencrypt-prod , https://acme-v02.api.letsencrypt.org/directory use e nas definições de recurso e ao instalar o gráfico Helm.In production deployments, use letsencrypt-prod and https://acme-v02.api.letsencrypt.org/directory in the resource definitions and when installing the Helm chart.

Para instalar o controlador CERT-Manager em um cluster habilitado para RBAC, use o seguinte helm install comando:To install the cert-manager controller in an RBAC-enabled cluster, use the following helm install command:

# Install the CustomResourceDefinition resources separately
kubectl apply -f https://raw.githubusercontent.com/jetstack/cert-manager/release-0.8/deploy/manifests/00-crds.yaml

# Create the namespace for cert-manager
kubectl create namespace cert-manager

# Label the cert-manager namespace to disable resource validation
kubectl label namespace cert-manager certmanager.k8s.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 \
  --name cert-manager \
  --namespace cert-manager \
  --version v0.8.0 \
  jetstack/cert-manager

Para obter mais informações sobre a configuração do Gerenciador de certificados, consulte o projeto CERT-Manager.For more information on cert-manager configuration, see the cert-manager project.

Criar um emissor de cluster de autoridade de certificaçãoCreate a CA cluster issuer

Antes que os certificados possam ser emitidos, o CERT-Manager requer um recurso de emissor ou ClusterIssuer .Before certificates can be issued, cert-manager requires an Issuer or ClusterIssuer resource. Esses recursos kubernetes são idênticos na funcionalidade, Issuer no entanto, funcionam em um ClusterIssuer único namespace e funcionam em todos os namespaces.These Kubernetes resources are identical in functionality, however Issuer works in a single namespace, and ClusterIssuer works across all namespaces. Para obter mais informações, consulte a documentação do emissor do Gerenciador de certificados .For more information, see the cert-manager issuer documentation.

Crie um emissor de cluster, como cluster-issuer.yaml, usando o manifesto de exemplo a seguir.Create a cluster issuer, such as cluster-issuer.yaml, using the following example manifest. Atualize o endereço de email com um endereço válido da sua organização:Update the email address with a valid address from your organization:

apiVersion: certmanager.k8s.io/v1alpha1
kind: ClusterIssuer
metadata:
  name: letsencrypt-staging
  namespace: ingress-basic
spec:
  acme:
    server: https://acme-staging-v02.api.letsencrypt.org/directory
    email: user@contoso.com
    privateKeySecretRef:
      name: letsencrypt-staging
    http01: {}

Para criar o emissor, use o kubectl apply -f cluster-issuer.yaml comando.To create the issuer, use the kubectl apply -f cluster-issuer.yaml command.

$ kubectl apply -f cluster-issuer.yaml

clusterissuer.certmanager.k8s.io/letsencrypt-staging created

Executar aplicativos de demonstraçãoRun demo applications

Um controlador de entrada e uma solução de gerenciamento de certificados foram configurados.An ingress controller and a certificate management solution have been configured. Agora, vamos executar dois aplicativos de demonstração em seu cluster AKS.Now let's run two demo applications in your AKS cluster. Neste exemplo, Helm é usado para implantar duas instâncias de um aplicativo "Hello World" simples.In this example, Helm is used to deploy two instances of a simple 'Hello world' application.

Antes de instalar os gráficos de exemplo do Helm, adicione o repositório de exemplos do Azure ao seu ambiente Helm da seguinte maneira:Before you can install the sample Helm charts, add the Azure samples repository to your Helm environment as follows:

helm repo add azure-samples https://azure-samples.github.io/helm-charts/

Crie o primeiro aplicativo de demonstração de um gráfico do Helm com o seguinte comando:Create the first demo application from a Helm chart with the following command:

helm install azure-samples/aks-helloworld --namespace ingress-basic

Agora, instale uma segunda instância do aplicativo de demonstração.Now install a second instance of the demo application. Para a segunda instância, você especifica um novo título para que os dois aplicativos sejam visualmente distintos.For the second instance, you specify a new title so that the two applications are visually distinct. Você também especifica um nome de serviço exclusivo:You also specify a unique service name:

helm install azure-samples/aks-helloworld \
    --namespace ingress-basic \
    --set title="AKS Ingress Demo" \
    --set serviceName="ingress-demo"

Criar uma rota de entradaCreate an ingress route

Os dois aplicativos agora estão em execução no cluster kubernetes, no entanto, eles são configurados com um serviço do tipo ClusterIP.Both applications are now running on your Kubernetes cluster, however they're configured with a service of type ClusterIP. Assim, os aplicativos não são acessíveis pela Internet.As such, the applications aren't accessible from the internet. Para torná-los publicamente disponíveis, crie um recurso de entrada do kubernetes.To make them publicly available, create a Kubernetes ingress resource. O recurso de entrada configura as regras que roteiam o tráfego para um dos dois aplicativos.The ingress resource configures the rules that route traffic to one of the two applications.

No exemplo a seguir, o tráfego para o https://demo-aks-ingress.eastus.cloudapp.azure.com/ endereço é roteado para o aks-helloworldserviço chamado.In the following example, traffic to the address https://demo-aks-ingress.eastus.cloudapp.azure.com/ is routed to the service named aks-helloworld. O tráfego para o https://demo-aks-ingress.eastus.cloudapp.azure.com/hello-world-two endereço é roteado ingress-demo para o serviço.Traffic to the address https://demo-aks-ingress.eastus.cloudapp.azure.com/hello-world-two is routed to the ingress-demo service. Atualize os hosts e o host para o nome DNS que você criou em uma etapa anterior.Update the hosts and host to the DNS name you created in a previous step.

Crie um arquivo chamado hello-world-ingress.yaml e copie no exemplo a seguir YAML.Create a file named hello-world-ingress.yaml and copy in the following example YAML.

apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: hello-world-ingress
  namespace: ingress-basic
  annotations:
    kubernetes.io/ingress.class: nginx
    certmanager.k8s.io/cluster-issuer: letsencrypt-staging
    nginx.ingress.kubernetes.io/rewrite-target: /$1
spec:
  tls:
  - hosts:
    - demo-aks-ingress.eastus.cloudapp.azure.com
    secretName: tls-secret
  rules:
  - host: demo-aks-ingress.eastus.cloudapp.azure.com
    http:
      paths:
      - backend:
          serviceName: aks-helloworld
          servicePort: 80
        path: /(.*)
      - backend:
          serviceName: ingress-demo
          servicePort: 80
        path: /hello-world-two(/|$)(.*)

Crie o recurso de entrada usando o kubectl apply -f hello-world-ingress.yaml comando.Create the ingress resource using the kubectl apply -f hello-world-ingress.yaml command.

$ kubectl apply -f hello-world-ingress.yaml

ingress.extensions/hello-world-ingress created

Criar um objeto de certificadoCreate a certificate object

Em seguida, um recurso de certificado deve ser criado.Next, a certificate resource must be created. O recurso de certificado define o certificado X. 509 desejado.The certificate resource defines the desired X.509 certificate. Para obter mais informações, consulte certificados do Gerenciador decertificados.For more information, see cert-manager certificates.

O CERT-Manager provavelmente criou automaticamente um objeto de certificado para você usando o Shim de entrada, que é implantado automaticamente com o CERT-Manager desde o v 0.2.2.Cert-manager has likely automatically created a certificate object for you using ingress-shim, which is automatically deployed with cert-manager since v0.2.2. Para obter mais informações, consulte a documentação de Shim da entrada.For more information, see the ingress-shim documentation.

Para verificar se o certificado foi criado com êxito, use o kubectl describe certificate tls-secret --namespace ingress-basic comando.To verify that the certificate was created successfully, use the kubectl describe certificate tls-secret --namespace ingress-basic command.

Se o certificado foi emitido, você verá uma saída semelhante à seguinte:If the certificate was issued, you will see output similar to the following:

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

Se você precisar criar um recurso de certificado adicional, poderá fazer isso com o manifesto de exemplo a seguir.If you need to create an additional certificate resource, you can do so with the following example manifest. Atualize o dnsNames e os domínios para o nome DNS que você criou em uma etapa anterior.Update the dnsNames and domains to the DNS name you created in a previous step. Se você usar um controlador de entrada somente interno, especifique o nome DNS interno para seu serviço.If you use an internal-only ingress controller, specify the internal DNS name for your service.

apiVersion: certmanager.k8s.io/v1alpha1
kind: Certificate
metadata:
  name: tls-secret
  namespace: ingress-basic
spec:
  secretName: tls-secret-staging
  dnsNames:
  - demo-aks-ingress.eastus.cloudapp.azure.com
  acme:
    config:
    - http01:
        ingressClass: nginx
      domains:
      - demo-aks-ingress.eastus.cloudapp.azure.com
  issuerRef:
    name: letsencrypt-staging
    kind: ClusterIssuer

Para criar o recurso de certificado, use kubectl apply -f certificates.yaml o comando.To create the certificate resource, use the kubectl apply -f certificates.yaml command.

$ kubectl apply -f certificates.yaml

certificate.certmanager.k8s.io/tls-secret-staging created

Testar a configuração de entradaTest the ingress configuration

Abra um navegador da Web para o FQDN do controlador de entrada do kubernetes, como https://demo-aks-ingress.eastus.cloudapp.azure.com .Open a web browser to the FQDN of your Kubernetes ingress controller, such as https://demo-aks-ingress.eastus.cloudapp.azure.com.

Como esses exemplos usam letsencrypt-staging, o certificado SSL emitido não é confiável para o navegador.As these examples use letsencrypt-staging, the issued SSL certificate is not trusted by the browser. Aceite a solicitação de aviso para continuar em seu aplicativo.Accept the warning prompt to continue to your application. As informações de certificado mostram que esse certificado falso Le intermediário X1 é emitido por criptografar.The certificate information shows this Fake LE Intermediate X1 certificate is issued by Let's Encrypt. Esse certificado falso indica cert-manager que a solicitação foi processada corretamente e recebeu um certificado do provedor:This fake certificate indicates cert-manager processed the request correctly and received a certificate from the provider:

Vamos criptografar o certificado de preparo

Quando você altera, vamos criptografar para prod uso em stagingvez de, um certificado confiável emitido por vamos criptografar é usado, conforme mostrado no exemplo a seguir:When you change Let's Encrypt to use prod rather than staging, a trusted certificate issued by Let's Encrypt is used, as shown in the following example:

Vamos criptografar o certificado

O aplicativo de demonstração é mostrado no navegador da Web:The demo application is shown in the web browser:

Exemplo de aplicativo One

Agora, adicione o caminho /Hello-World-Two ao FQDN, https://demo-aks-ingress.eastus.cloudapp.azure.com/hello-world-two como.Now add the /hello-world-two path to the FQDN, such as https://demo-aks-ingress.eastus.cloudapp.azure.com/hello-world-two. O segundo aplicativo de demonstração com o título personalizado é mostrado:The second demo application with the custom title is shown:

Exemplo de aplicativo dois

Limpar recursosClean up resources

Este artigo usou o Helm para instalar os componentes de entrada, os certificados e os aplicativos de exemplo.This article used Helm to install the ingress components, certificates, and sample apps. Quando você implanta um gráfico do Helm, vários recursos do kubernetes são criados.When you deploy a Helm chart, a number of Kubernetes resources are created. Esses recursos incluem pods, implantações e serviços.These resources includes pods, deployments, and services. Para limpar esses recursos, você pode excluir o namespace de exemplo inteiro ou os recursos individuais.To clean up these resources, you can either delete the entire sample namespace, or the individual resources.

Excluir o namespace de exemplo e todos os recursosDelete the sample namespace and all resources

Para excluir o namespace de exemplo inteiro, use kubectl delete o comando e especifique o nome do namespace.To delete the entire sample namespace, use the kubectl delete command and specify your namespace name. Todos os recursos no namespace são excluídos.All the resources in the namespace are deleted.

kubectl delete namespace ingress-basic
kubectl delete namespace cert-manager

Em seguida, remova o repositório Helm para o aplicativo Hello World do AKS:Then, remove the Helm repo for the AKS hello world app:

helm repo remove azure-samples

Excluir recursos individualmenteDelete resources individually

Como alternativa, uma abordagem mais granular é excluir os recursos individuais criados.Alternatively, a more granular approach is to delete the individual resources created. Primeiro, remova os recursos de certificado:First, remove the certificate resources:

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

Agora, liste as versões Helm helm list com o comando.Now list the Helm releases with the helm list command. Procure gráficos chamados Nginx-ingress, CERT-Managere AKs-HelloWorld, conforme mostrado na seguinte saída de exemplo:Look for charts named nginx-ingress, cert-manager, and aks-helloworld, as shown in the following example output:

$ helm list

NAME                    REVISION    UPDATED                     STATUS      CHART                   APP VERSION NAMESPACE
billowing-kitten        1           Wed Mar  6 19:37:43 2019    DEPLOYED    nginx-ingress-1.3.1     0.22.0      kube-system
loitering-waterbuffalo  1           Wed Mar  6 20:25:01 2019    DEPLOYED    cert-manager-v0.6.6     v0.6.2      kube-system
flabby-deer             1           Wed Mar  6 20:27:54 2019    DEPLOYED    aks-helloworld-0.1.0                default
linting-echidna         1           Wed Mar  6 20:27:59 2019    DEPLOYED    aks-helloworld-0.1.0                default

Exclua as versões com helm delete o comando.Delete the releases with the helm delete command. O exemplo a seguir exclui a implantação de entrada do NGINX, o Gerenciador de certificados e os dois exemplos de aplicativos do Hello World do AKS.The following example deletes the NGINX ingress deployment, certificate manager, and the two sample AKS hello world apps.

$ helm delete billowing-kitten loitering-waterbuffalo flabby-deer linting-echidna

release "billowing-kitten" deleted
release "loitering-waterbuffalo" deleted
release "flabby-deer" deleted
release "linting-echidna" deleted

Em seguida, remova o repositório Helm para o aplicativo Hello World do AKS:Next, remove the Helm repo for the AKS hello world app:

helm repo remove azure-samples

Exclua o namespace em si.Delete the itself namespace. Use o kubectl delete comando e especifique o nome do namespace:Use the kubectl delete command and specify your namespace name:

kubectl delete namespace ingress-basic

Por fim, remova a rota de entrada que direcionou o tráfego para os aplicativos de exemplo:Finally, remove the ingress route that directed traffic to the sample apps:

kubectl delete -f hello-world-ingress.yaml

Passos seguintesNext steps

Este artigo incluía alguns componentes externos no AKS.This article included some external components to AKS. Para saber mais sobre esses componentes, consulte as seguintes páginas do projeto:To learn more about these components, see the following project pages:

Também pode:You can also: