Pré-requisitos - Um servidor Ubuntu 20.04 com um usuário não root com privilégios `sudo`.
- Um cluster Kubernetes instalado no servidor, como `kubeadm`, `k3s`, `minikube`, `Rancher`, etc.
- Acesso à linha de comando/janela do terminal.
Etapa 1:Atualizar o sistema
Atualize suas listas de pacotes antes de prosseguir com qualquer instalação:
```sh
sudo apt update &&sudo apt upgrade -y
```
Etapa 2:Adicionar repositório do Kong Kong Gateway
Importe a chave GPG para o repositório Kubernetes, que ajuda a identificar o editor do pacote.
```sh
curl https://download.konghq.com/keyring/kong.gpg | sudo apt-key adicionar -
```
Crie a lista de repositórios Kong para que o apt possa obter o Kong da fonte oficial.
```sh
echo "deb [arch=amd64] https://download.konghq.com/deb estável principal" | sudo tee /etc/apt/sources.list.d/kong.list
```
Etapa 3:Instale o Kong Gateway
Agora, instale o Kong Gateway usando o gerenciador de pacotes padrão, apt.
```sh
sudo apto instalar kong
```
Este comando deve instalar o Kong Gateway e todas as suas dependências.
Etapa 4:ativar e verificar o serviço Kong
Assim que a instalação for concluída, execute o seguinte comando para habilitar o serviço Kong:
```sh
sudo systemctl habilitar kong
```
E então, inicie o serviço Kong:
```sh
sudo systemctl iniciar kong
```
Para verificar se o serviço Kong está em execução, use o seguinte comando:
```sh
sudo systemctl status kong
```
Etapa 5:instalar o controlador Ingress
A seguir, instalaremos o Kong Ingress Controller, que atua como uma ponte entre o Kong Gateway e o Kubernetes.
Execute o seguinte comando para instalar o Kong Ingress Controller usando Helm, o gerenciador de pacotes Kubernetes:
```sh
helm repo adicionar kong https://charts.konghq.com
atualização do repositório do helm
helm instalar kong/kong-ingress-controller --namespace=kong --create-namespace
```
Isso instala o Kong Ingress Controller em um namespace `kong` recém-criado.
Etapa 6:configurar o acesso de tráfego externo ao Kong Gateway
Por padrão, o Kong Gateway escuta solicitações na interface local e na porta 8000. Para permitir o acesso remoto de fora do seu servidor, como dos clientes do seu cluster, precisamos configurar as políticas de rede do Kubernetes.
Crie a política de rede necessária usando `kubectl`:
```sh
kubectl criar -f - <
apiVersão:networking.k8s.io/v1
tipo:Política de rede
metadados:
nome:permitir-tráfego
especificação:
podSelector:{}
entrada:
- de:
-seletor de namespace:
rótulos de correspondência:
nome:Kong
portos:
- porta:8000
protocolo:TCP
EOF
```
Esta política de rede permite que todos os pods no namespace `kong` enviem tráfego para o Kong Gateway.
Etapa 7:Testando o Kong Gateway
Para testar se o Kong Gateway está funcionando conforme o esperado, envie uma solicitação para ele. Execute o seguinte comando para enviar uma solicitação HTTP usando `curl`.
```sh
curl -IL http://localhost:8000
```
Você deverá receber uma resposta HTTP 404, indicando que o Kong Gateway está recebendo a solicitação, mas nenhuma rota ou serviço correspondente está disponível.
Etapa 8:Integração com serviços Kubernetes
Para concluir a configuração, você pode implantar um aplicativo simples em seu cluster Kubernetes e usar o Kong Gateway como controlador de entrada para rotear solicitações para o aplicativo.
Aqui está um exemplo de manifesto `Deployment` para um aplicativo simples chamado `nginx`:
```yaml
apiVersão:apps/v1
tipo:implantação
metadados:
nome:nginx
rótulos:
aplicativo:nginx
especificação:
seletor:
rótulos de correspondência:
aplicativo:nginx
réplicas:1
modelo:
metadados:
rótulos:
aplicativo:nginx
especificação:
recipientes:
- nome:nginx
imagem:nginx:1.21
portos:
- porta do contêiner:80
nome:http
```
Salve-o em um arquivo chamado `nginx.yaml`. Em seguida, implante-o em seu cluster Kubernetes:
```sh
kubectl aplicar -f nginx.yaml
```
Isso cria uma implantação para um servidor Nginx simples.
#### Criando o serviço
Em seguida, crie um serviço Kubernetes que exponha a porta 80 de todos os pods com o rótulo `app=nginx`:
```yaml
versão api:v1
tipo:Serviço
metadados:
nome:nginx
rótulos:
aplicativo:nginx
especificação:
portos:
- porta:80
nome:http
seletor:
aplicativo:nginx
```
Salve-o em um arquivo chamado `nginx-service.yaml`. Em seguida, implante-o em seu cluster Kubernetes:
```sh
kubectl apply -f nginx-service.yaml
```
#### Criando o KongRoute
Por fim, configure o Kong Gateway para rotear o tráfego para nosso serviço `nginx`. Abaixo está um exemplo de manifesto para um KongRoute:
```yaml
apiVersão:konghq.com/v1
tipo:KongRoute
metadados:
nome:exemplo
especificação:
protocolos:
- https
anfitrião:exemplo.com
caminhos:
- /
serviço:
nome:nginx-kong
porta:80
protocolo:http
```
Salve este manifesto em um arquivo chamado `example-route.yaml` e aplique-o ao seu cluster Kubernetes:
```sh
kubectl apply -f exemplo-route.yaml
```
Isso cria uma configuração, dizendo ao Kong Gateway para aceitar solicitações HTTPS para o domínio `example.com` e roteá-las para nosso serviço `nginx` em execução na porta 80 usando HTTP.
Testando roteamento
Agora você pode testar o roteamento do Kong Gateway. Em qualquer máquina com acesso ao cluster Kubernetes, execute:
```sh
curl -k https://example.com
```
Se tudo estiver configurado corretamente, você deverá ver a página de boas-vindas padrão do Nginx.
Parabéns! Você instalou com êxito o Kong Gateway no Ubuntu Linux, configurou o Ingress Controller, configurou políticas de rede e testou o roteamento para um aplicativo em seu cluster Kubernetes.
