Como o Amazon EKS e o APISIX Ingress Controller trabalham juntos para gerenciar tráfego complexo

API7.ai

February 7, 2021

Ecosystem

Contexto

Como gerente de tráfego, às vezes, mesmo quando você está preparado para o inesperado, é difícil evitar o inesperado. Construir um gateway de API de quatro vias é crucial! Veja como Amazon EKS + Ingress APISIX! pode ajudar com isso hoje.

Introdução

Kubernetes é um sistema de código aberto para automatizar a implantação, dimensionamento e gerenciamento de aplicações em contêineres. O Amazon Elastic Kubernetes Service (Amazon EKS) como um serviço gerenciado de Kubernetes permite que você execute cargas do Kubernetes facilmente na Amazon Cloud Technologies sem a necessidade de instalação e manutenção do plano de controle ou dos nós.

O Apache APISIX é um gateway de API dinâmico, em tempo real e de alto desempenho. Ele fornece recursos avançados de gerenciamento de tráfego, como balanceamento de carga, upstream dinâmico, implantação em escala cinza, segmentação de tráfego, autenticação e observabilidade. Você pode usar o Apache APISIX para lidar com o tráfego norte-sul entre clientes tradicionais e servidores, bem como o tráfego leste-oeste entre serviços.

O Ingress APISIX pode ser usado como o controlador de entrada para o Kubernetes, trazendo os melhores recursos do Apache APISIX para o Kubernetes. Isso pode ser impulsionado por componentes de controlador bem projetados para ajudá-lo a atender às necessidades complexas de gerenciamento de tráfego.

Arquitetura técnica do apisix-ingress-controller

Como configurar e executar o Ingress APISIX no Amazon Elastic Kubernetes Service

Requisitos Prévios

Antes de começar, configure um cluster Amazon EKS disponível na Amazon CloudTech.

Você deve ter a ferramenta kubectl no seu ambiente e definir o contexto para o seu próprio cluster Amazon EKS executando o seguinte comando:

aws eks update-kubeconfig --name  --region

Assim que o cluster Kubernetes estiver pronto, crie um namespace chamado ingress-apisix, onde todos os recursos que serão usados serão criados.

kubectl create namespace ingress-apisix

Usaremos o Helm para implantar todos os componentes do Ingress APISIX (Apache APISIX e apisix-ingress-controller), então siga o guia de instalação para instalar o Helm. O chart do Helm para o Apache APISIX e o apisix-ingress-controller está localizado em apache/apisix-helm-chart e apache/apisix-ingress-controller. Clone esses repositórios para obter os charts correspondentes.

Instalando o Apache APISIX

O Apache APISIX atua como um plano de proxy para o apisix-ingress-controller e deve ser implantado antecipadamente.

cd /path/to/apisix-helm-chart
helm repo add bitnami https://charts.bitnami.com/bitnami
helm dependency update . /chart/apisix
helm install apisix . /chart/apisix \
  --set gateway.type=LoadBalancer \
  --set allow.ipList="{0.0.0.0/0}" \
  --namespace ingress-apisix
kubectl get service --namespace ingress-apisix

O comando acima criará dois recursos de serviço Kubernetes: apisix-gateway, que lida com o tráfego real, e apisix-admin, que atua como o plano de controle e lida com todas as alterações de configuração. Aqui, criamos o apisix-gateway como um serviço do tipo LoadBalancer, que pode ser exposto à Internet com a ajuda do Amazon Network Load Balancer. Podemos encontrar o nome do host do balanceador de carga com o seguinte comando:

kubectl get service apisix-gateway \
--namespace ingress-apisix \
-o jsonpath='{.status.loadBalancer.ingress[].hostname}'

Observe também: o campo allow.ipList deve ser ajustado para os intervalos CIDR do EKS no seu próprio cluster Amazon EKS, para que o apisix-ingress-controller possa ser autorizado pelo Apache APISIX (para enviar recursos).

Consulte value.yaml para mais informações sobre todos os itens de configuração, caso haja outros requisitos.

Instalando o apisix-ingress-controller

Após implantar o Apache APISIX com sucesso, é hora de instalar o componente Controller.

cd /path/to/apisix-ingress-controller
# instala recursos básicos, como ServiceAccount.
helm install ingress-apisix-base -n ingress-apisix . /charts/base
# instala o apisix-ingress-controller
helm install ingress-apisix . /charts/ingress-apisix \
  --set ingressController.image.tag=dev \
  --set ingressController.config.apisix.baseURL=http://apisix-admin:9180/apisix/admin \
  --set ingressController.config.apisix.adminKey={YOUR ADMIN KEY} \
  --namespace ingress-apisix

O chart ingress-apisix-base instalará algumas dependências básicas para o apisix-ingress-controller, como ServiceAccount e seus CRDs dedicados.

O chart ingress-apisix nos guiará na instalação do próprio Controller. Podemos alterar a tag da imagem para a versão desejada e ajustar o valor de ingressController.config.apisix.adminKey no comando acima. Essas configurações podem ser ajustadas de acordo com cenários reais (e certifique-se de que a chave Admin usada aqui seja a mesma usada na implantação do Apache APISIX). Se você tiver outros requisitos, consulte value.yaml para saber mais sobre todos os itens de configuração.

Em seguida, tente abrir o console do Amazon EKS, selecione seu cluster e clique na aba Workloads. Você verá que todos os Pods, etcd e apisix-ingress-controller para o Apache APISIX estão prontos.

Iniciando os testes

Neste ponto, implantamos todos os componentes do Ingress APISIX, então certifique-se de verificar se tudo está funcionando corretamente. Em seguida, implantaremos um serviço httpbin e pediremos ao Apache APISIX para rotear todas as solicitações para o host "local.httpbin.org" para este serviço.

Para isso, primeiro precisamos criar a carga de trabalho httpbin e expô-la.

kubectl run httpbin --image kennethreitz/httpbin --port 80
kubectl expose pod httpbin --port 80

Para que o Apache APISIX roteie as solicitações corretamente, precisamos criar um recurso ApisixRoute para impulsionar o processo.

# ar-httpbin.yaml
apiVersion: apisix.apache.org/v1
kind: ApisixRoute
metadata:
  name: httpserver-route
spec:
  rules:
  - host: local.httpbin.org
    http:
      paths:
      - backend:
          serviceName: httpbin
          servicePort: 80
        path: /*

O recurso ApisixRoute acima permitirá que o Apache APISIX roteie solicitações com o cabeçalho de host "local.httpbin.org" para o backend httpbin (que acabamos de criar).

Em seguida, aplique essa configuração, mas observe que o serviço e o recurso ApisixRoute devem estar no mesmo namespace, e o apisix-ingress-controller não pode cruzar namespaces.

kubectl apply -f ar-httpbin.yaml

Teste os resultados com uma simples chamada curl de qualquer lugar que possa alcançar o serviço Apache APISIX.

$ curl http://{apisix-gateway-ip}:{apisix-gateway-port}/headers -s -H 'Host: local.httpbin.org'

{
  "headers": {
    "Accept": "*/*",
    "Host": "httpbin.org",
    "User-Agent": "curl/7.64.1",
    "X-Amzn-Trace-Id": "Root=1-5ffc3273-2928e0844e19c9810d1bbd8a"
  }
}

Se o tipo de serviço for ClusterIP, você precisará fazer login em um Pod no cluster Amazon EKS e usar o ClusterIP ou o FQDN do serviço para acessar o Apache APISIX. Se já estiver exposto (NodePort ou LoadBalancer), você pode acessar diretamente o endpoint externo alcançável.

Nota: Este artigo foi reproduzido do site público do WeChat da AWS.

Tags:
APISIX Ingress Controller
AWS
Traffic Management