Forudsætninger
- En Ubuntu 20.04-server med en ikke-rootbruger med `sudo`-privilegier.
- En Kubernetes-klynge installeret på serveren, såsom `kubeadm`, `k3s`, `minikube`, `Rancher` osv.
- Adgang til kommandolinjen/terminalvinduet.
Trin 1:Opdater systemet
Opdater dine pakkelister, før du fortsætter med nogen installationer:
```sh
sudo apt update &&sudo apt upgrade -y
```
Trin 2:Tilføj Kong Kong Gateway Repository
Importer GPG-nøglen til Kubernetes-lageret, som hjælper med at identificere pakkens udgiver.
```sh
krølle https://download.konghq.com/keyring/kong.gpg | sudo apt-key add -
```
Opret Kong-lagerlisten, så apt kan hente Kong fra den officielle kilde.
```sh
echo "deb [arch=amd64] https://download.konghq.com/deb stabil main" | sudo tee /etc/apt/sources.list.d/kong.list
```
Trin 3:Installer Kong Gateway
Installer nu Kong Gateway ved hjælp af standardpakkehåndteringen, apt.
```sh
sudo apt install kong
```
Denne kommando skal installere Kong Gateway og alle dens afhængigheder.
Trin 4:Aktiver og tjek Kong Service
Når installationen er færdig, skal du køre følgende kommando for at aktivere Kong-tjenesten:
```sh
sudo systemctl aktiver kong
```
Og start derefter Kong-tjenesten:
```sh
sudo systemctl start kong
```
For at kontrollere, om Kong-tjenesten kører, skal du bruge følgende kommando:
```sh
sudo systemctl status kong
```
Trin 5:Installer Ingress Controller
Dernæst installerer vi Kong Ingress Controller, der fungerer som en bro mellem Kong Gateway og Kubernetes.
Kør følgende kommando for at installere Kong Ingress Controller ved hjælp af Helm, Kubernetes-pakkehåndteringen:
```sh
helm repo tilføje kong https://charts.konghq.com
opdatering af ror repo
helm installer kong/kong-ingress-controller --namespace=kong --create-namespace
```
Dette installerer Kong Ingress Controller i et nyoprettet `kong` navneområde.
Trin 6:Konfiguration af ekstern trafikadgang til Kong Gateway
Som standard lytter Kong Gateway efter anmodninger på den lokale grænseflade og port 8000. For at tillade fjernadgang uden for din server, f.eks. fra klienterne i din klynge, skal vi konfigurere Kubernetes' netværkspolitikker.
Opret den nødvendige netværkspolitik ved hjælp af `kubectl`:
```sh
kubectl oprette -f - <
apiVersion:networking.k8s.io/v1
type:NetworkPolicy
metadata:
navn:tillad-trafik
spec:
podSelector:{}
indtrængen:
- fra:
- navnerumsvælger:
matchLabels:
navn:kong
havne:
- port:8000
protokol:TCP
EOF
```
Denne netværkspolitik tillader alle pods i `kong`-navneområdet at sende trafik til Kong Gateway.
Trin 7:Test af Kong Gateway
For at teste, om Kong Gateway fungerer som forventet, skal du sende en anmodning til den. Kør følgende kommando for at sende en HTTP-anmodning ved hjælp af `curl`.
```sh
curl -IL http://localhost:8000
```
Du bør modtage et HTTP 404-svar, der indikerer, at Kong Gateway modtager anmodningen, men ingen matchende ruter eller tjenester er tilgængelige.
Trin 8:Integration med Kubernetes Services
For at fuldføre opsætningen kan du implementere en simpel applikation i din Kubernetes-klynge og bruge Kong Gateway som indgangscontroller til at dirigere anmodninger til applikationen.
Her er et eksempel på et "Deployment"-manifest for en simpel applikation ved navn "nginx":
``` yaml
apiVersion:apps/v1
type:Implementering
metadata:
navn:nginx
etiketter:
app:nginx
spec:
vælger:
matchLabels:
app:nginx
kopier:1
skabelon:
metadata:
etiketter:
app:nginx
spec:
beholdere:
- navn:nginx
billede:nginx:1.21
havne:
- containerPort:80
navn:http
```
Gem det i en fil med navnet `nginx.yaml`. Derefter skal du implementere det til din Kubernetes-klynge:
```sh
kubectl anvende -f nginx.yaml
```
Dette skaber en implementering til en simpel Nginx-server.
#### Oprettelse af tjenesten
Derefter skal du oprette en Kubernetes-tjeneste, der afslører port 80 af alle pods med etiketten `app=nginx`:
``` yaml
apiVersion:v1
art:Service
metadata:
navn:nginx
etiketter:
app:nginx
spec:
havne:
- port:80
navn:http
vælger:
app:nginx
```
Gem det i en fil med navnet `nginx-service.yaml`. Derefter skal du implementere det til din Kubernetes-klynge:
```sh
kubectl anvende -f nginx-service.yaml
```
#### Oprettelse af KongRoute
Til sidst skal du konfigurere Kong Gateway til at dirigere trafik til vores `nginx`-tjeneste. Nedenfor er et eksempel på et manifest for en KongRoute:
``` yaml
apiVersion:konghq.com/v1
slags:KongRoute
metadata:
navn:eksempel
spec:
protokoller:
- https
vært:eksempel.com
stier:
- /
service:
navn:nginx-kong
port:80
protokol:http
```
Gem dette manifest i en fil med navnet `example-route.yaml` og anvend det på din Kubernetes-klynge:
```sh
kubectl anvende -f eksempel-rute.yaml
```
Dette opretter en konfiguration, der fortæller Kong Gateway at acceptere HTTPS-anmodninger til domænet `example.com` og dirigere dem til vores `nginx`-tjeneste, der kører på port 80 ved hjælp af HTTP.
Test routing
Nu kan du teste Kong Gateway-rutingen. Fra enhver maskine med adgang til Kubernetes-klyngen skal du køre:
```sh
curl -k https://example.com
```
Hvis alt er konfigureret korrekt, bør du se standard Nginx velkomstside.
Tillykke! Du har med succes installeret Kong Gateway på Ubuntu Linux, konfigureret Ingress Controller, konfigureret netværkspolitikker og testet routing til en applikation i din Kubernetes-klynge.
