- Un servidor Ubuntu 20.04 con un usuario no root con privilegios `sudo`.
- Un clúster de Kubernetes instalado en el servidor, como `kubeadm`, `k3s`, `minikube`, `Rancher`, etc.
- Acceso a la línea de comando/ventana de terminal.
Paso 1:Actualizar el sistema
Actualice sus listas de paquetes antes de continuar con cualquier instalación:
```sh
sudo apt actualización &&sudo apt actualización -y
```
Paso 2:Agregar el repositorio de Kong Kong Gateway
Importe la clave GPG para el repositorio de Kubernetes, que ayuda a identificar al editor del paquete.
```sh
rizo https://download.konghq.com/keyring/kong.gpg | sudo apt-key agregar -
```
Cree la lista de repositorios de Kong para que apt pueda obtener Kong de la fuente oficial.
```sh
echo "deb [arch=amd64] https://download.konghq.com/deb estable principal" | sudo tee /etc/apt/sources.list.d/kong.list
```
Paso 3:Instalar Kong Gateway
Ahora, instale Kong Gateway usando el administrador de paquetes estándar, apto.
```sh
sudo apto instalar kong
```
Este comando debería instalar Kong Gateway y todas sus dependencias.
Paso 4:habilitar y verificar el servicio Kong
Una vez que se complete la instalación, ejecute el siguiente comando para habilitar el servicio Kong:
```sh
sudo systemctl habilitar kong
```
Y luego, inicia el servicio Kong:
```sh
sudo systemctl iniciar kong
```
Para verificar si el servicio Kong se está ejecutando, use el siguiente comando:
```sh
sudo systemctl estado kong
```
Paso 5:Instalar el controlador de ingreso
A continuación, instalaremos Kong Ingress Controller, que actúa como puente entre Kong Gateway y Kubernetes.
Ejecute el siguiente comando para instalar Kong Ingress Controller usando Helm, el administrador de paquetes de Kubernetes:
```sh
repositorio de timón agregar kong https://charts.konghq.com
actualización del repositorio de timón
helm instalar kong/kong-ingress-controller --namespace=kong --create-namespace
```
Esto instala Kong Ingress Controller en un espacio de nombres "kong" recién creado.
Paso 6:Configurar el acceso al tráfico externo a Kong Gateway
De forma predeterminada, Kong Gateway escucha solicitudes en la interfaz local y el puerto 8000. Para permitir el acceso remoto desde fuera de su servidor, como desde los clientes de su clúster, debemos configurar las Políticas de red de Kubernetes.
Cree la política de red necesaria usando `kubectl`:
```sh
kubectl crear -f - <
tipo:Política de red
metadatos:
nombre:permitir-trafico
especulación:
selector de pods:{}
ingreso:
- de:
- selector de espacio de nombres:
coincidirEtiquetas:
nombre:kong
puertos:
- puerto:8000
protocolo:TCP
EOF
```
Esta Política de red permite que todos los pods en el espacio de nombres "kong" envíen tráfico a Kong Gateway.
Para probar si Kong Gateway funciona como se esperaba, envíele una solicitud. Ejecute el siguiente comando para enviar una solicitud HTTP utilizando `curl`.
```sh
rizo -IL http://localhost:8000
```
Debería recibir una respuesta HTTP 404, que indica que Kong Gateway está recibiendo la solicitud pero no hay rutas ni servicios coincidentes disponibles.
Para completar la configuración, puede implementar una aplicación simple en su clúster de Kubernetes y usar Kong Gateway como controlador de ingreso para enrutar solicitudes a la aplicación.
Aquí hay un ejemplo de manifiesto de "Implementación" para una aplicación simple llamada "nginx":
```yaml
Versión api:aplicaciones/v1
tipo:Despliegue
metadatos:
nombre:nginx
etiquetas:
aplicación:nginx
especulación:
selector:
coincidirEtiquetas:
aplicación:nginx
réplicas:1
plantilla:
metadatos:
etiquetas:
aplicación:nginx
especulación:
contenedores:
- nombre:nginx
imagen:nginx:1.21
puertos:
- puerto de contenedores:80
nombre:http
```
Guárdelo en un archivo llamado `nginx.yaml`. Luego, impleméntelo en su clúster de Kubernetes:
```sh
kubectl aplicar -f nginx.yaml
```
Esto crea una implementación para un servidor Nginx simple.
#### Creando el servicio
A continuación, cree un servicio de Kubernetes que exponga el puerto 80 de todos los pods con la etiqueta `app=nginx`:
```yaml
Versión api:v1
tipo:Servicio
metadatos:
nombre:nginx
etiquetas:
aplicación:nginx
especulación:
puertos:
- puerto:80
nombre:http
selector:
aplicación:nginx
```
Guárdelo en un archivo llamado `nginx-service.yaml`. Luego, impleméntelo en su clúster de Kubernetes:
```sh
kubectl aplicar -f nginx-service.yaml
```
#### Creando la ruta KongRoute
Finalmente, configure Kong Gateway para enrutar el tráfico a nuestro servicio `nginx`. A continuación se muestra un ejemplo de manifiesto para KongRoute:
```yaml
Versión api:konghq.com/v1
tipo:KongRoute
metadatos:
nombre:ejemplo
especulación:
protocolos:
- https
anfitrión:ejemplo.com
caminos:
- /
servicio:
nombre:nginx-kong
puerto:80
protocolo:http
```
Guarde este manifiesto en un archivo llamado `example-route.yaml` y aplíquelo a su clúster de Kubernetes:
```sh
kubectl aplicar -f ejemplo-ruta.yaml
```
Esto crea una configuración que le indica a Kong Gateway que acepte solicitudes HTTPS al dominio `example.com` y las enrute a nuestro servicio `nginx` que se ejecuta en el puerto 80 usando HTTP.
Ahora puede probar el enrutamiento de Kong Gateway. Desde cualquier máquina con acceso al clúster de Kubernetes, ejecute:
```sh
curl -k https://ejemplo.com
```
Si todo está configurado correctamente, debería ver la página de bienvenida predeterminada de Nginx.
¡Felicidades! Instaló correctamente Kong Gateway en Ubuntu Linux, configuró el controlador de ingreso, configuró las políticas de red y probó el enrutamiento a una aplicación en su clúster de Kubernetes.
Paso 7:Probar Kong Gateway
Paso 8:Integración con los servicios de Kubernetes
Prueba de enrutamiento