Forutsetninger
- En Ubuntu 20.04-server med en ikke-rootbruker med "sudo"-privilegier.
- En Kubernetes-klynge installert på serveren, som "kubeadm", "k3s", "minikube", "Rancher", etc.
- Tilgang til kommandolinjen/terminalvinduet.
Trinn 1:Oppdater systemet
Oppdater pakkelistene dine før du fortsetter med noen installasjoner:
```sh
sudo apt update &&sudo apt upgrade -y
```
Trinn 2:Legg til Kong Kong Gateway Repository
Importer GPG-nøkkelen for Kubernetes-depotet, som hjelper til med å identifisere pakkens utgiver.
```sh
krølle https://download.konghq.com/keyring/kong.gpg | sudo apt-key add -
```
Lag Kong-repository-listen slik at apt kan hente Kong fra den offisielle kilden.
```sh
echo "deb [arch=amd64] https://download.konghq.com/deb stabil main" | sudo tee /etc/apt/sources.list.d/kong.list
```
Trinn 3:Installer Kong Gateway
Installer nå Kong Gateway ved å bruke standard pakkebehandling, apt.
```sh
sudo apt install kong
```
Denne kommandoen skal installere Kong Gateway og alle dens avhengigheter.
Trinn 4:Aktiver og sjekk Kong-tjenesten
Når installasjonen er fullført, kjør følgende kommando for å aktivere Kong-tjenesten:
```sh
sudo systemctl aktiver kong
```
Og start deretter Kong-tjenesten:
```sh
sudo systemctl start kong
```
For å bekrefte om Kong-tjenesten kjører, bruk følgende kommando:
```sh
sudo systemctl status kong
```
Trinn 5:Installer Ingress Controller
Deretter installerer vi Kong Ingress Controller, som fungerer som en bro mellom Kong Gateway og Kubernetes.
Kjør følgende kommando for å installere Kong Ingress Controller ved å bruke Helm, Kubernetes-pakkebehandleren:
```sh
helm repo legg til kong https://charts.konghq.com
ror repo oppdatering
helm installer kong/kong-ingress-controller --namespace=kong --create-namespace
```
Dette installerer Kong Ingress Controller i et nyopprettet `kong` navneområde.
Trinn 6:Konfigurering av ekstern trafikktilgang til Kong Gateway
Som standard lytter Kong Gateway etter forespørsler på det lokale grensesnittet og port 8000. For å tillate ekstern tilgang fra utenfor serveren din, for eksempel fra klientene i klyngen din, må vi konfigurere Kubernetes' nettverkspolicyer.
Lag den nødvendige nettverkspolicyen ved å bruke `kubectl`:
```sh
kubectl opprette -f - <
apiVersjon:networking.k8s.io/v1
type:NetworkPolicy
metadata:
navn:tillate-trafikk
spesifikasjon:
podSelector:{}
ingress:
- fra:
- navneromvelger:
matchEtiketter:
navn:kong
porter:
- port:8000
protokoll:TCP
EOF
```
Denne nettverkspolicyen lar alle pods i `kong`-navneområdet sende trafikk til Kong Gateway.
Trinn 7:Testing av Kong Gateway
For å teste om Kong Gateway fungerer som forventet, send en forespørsel til den. Kjør følgende kommando for å sende en HTTP-forespørsel ved å bruke `curl`.
```sh
curl -IL http://localhost:8000
```
Du bør motta et HTTP 404-svar som indikerer at Kong Gateway mottar forespørselen, men ingen matchende ruter eller tjenester er tilgjengelige.
Trinn 8:Integrasjon med Kubernetes Services
For å fullføre oppsettet kan du distribuere en enkel applikasjon i Kubernetes-klyngen din og bruke Kong Gateway som inngangskontroller for å rute forespørsler til applikasjonen.
Her er et eksempel på et «Deployment»-manifest for en enkel applikasjon kalt «nginx»:
``` jaml
apiVersjon:apps/v1
type:Utrulling
metadata:
navn:nginx
etiketter:
app:nginx
spesifikasjon:
velger:
matchEtiketter:
app:nginx
kopier:1
mal:
metadata:
etiketter:
app:nginx
spesifikasjon:
beholdere:
- navn:nginx
bilde:nginx:1.21
porter:
- containerPort:80
navn:http
```
Lagre den i en fil som heter `nginx.yaml`. Deretter distribuerer du den til Kubernetes-klyngen din:
```sh
kubectl gjelder -f nginx.yaml
```
Dette skaper en distribusjon for en enkel Nginx-server.
#### Opprette tjenesten
Deretter oppretter du en Kubernetes-tjeneste som viser port 80 for alle pods med etiketten 'app=nginx':
``` jaml
apiVersjon:v1
type:Service
metadata:
navn:nginx
etiketter:
app:nginx
spesifikasjon:
porter:
- port:80
navn:http
velger:
app:nginx
```
Lagre den i en fil som heter `nginx-service.yaml`. Deretter distribuerer du den til Kubernetes-klyngen din:
```sh
kubectl gjelder -f nginx-service.yaml
```
#### Opprette KongRoute
Til slutt, konfigurer Kong Gateway til å rute trafikk til vår `nginx`-tjeneste. Nedenfor er et eksempelmanifest for en KongRoute:
``` jaml
apiVersjon:konghq.com/v1
type:KongRoute
metadata:
navn:eksempel
spesifikasjon:
protokoller:
- https
vert:eksempel.com
stier:
- /
service:
navn:nginx-kong
port:80
protokoll:http
```
Lagre dette manifestet i en fil som heter `example-route.yaml` og bruk det på Kubernetes-klyngen din:
```sh
kubectl anvende -f eksempel-rute.yaml
```
Dette oppretter en konfigurasjon som ber Kong Gateway om å akseptere HTTPS-forespørsler til domenet `example.com`, og rute dem til vår `nginx`-tjeneste som kjører på port 80 ved hjelp av HTTP.
Test ruting
Nå kan du teste Kong Gateway-rutingen. Fra hvilken som helst maskin med tilgang til Kubernetes-klyngen, kjør:
```sh
curl -k https://example.com
```
Hvis alt er satt opp riktig, bør du se standard Nginx-velkomstside.
Gratulerer! Du har installert Kong Gateway på Ubuntu Linux, satt opp Ingress Controller, konfigurert nettverkspolicyer og testet ruting til en applikasjon i Kubernetes-klyngen.
